2014多校联合六(HDU 4923 HDU 4925 HDU 4927 HDU 4930)

HDU 4923 Room and Moor

题意:给出A序列  求满足题目所写的B序列  使得方差最小

思路:可以想到最后的结果中  B序列的值一定是一段一段的  那么我们可以类似贪心去搞  对于一段序列我们可以求出什么样的b值使得方差最小  即序列中1的个数除以序列长度  又因为B是单调的  可以用一个单调栈去模拟  复杂度远远小于n^2  不要被吓怕…

代码:

#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
#define N 100010

int t, n, top;
int a[N], f[2][N];
struct st {
    int head;
    double val;
} g[N];

int main() {
    int i, idx, num;
    double tmp1, ans;
    scanf("%d", &t);
    while (t--) {
        scanf("%d", &n);
        for (i = 1; i <= n; i++) {
            scanf("%d", &a[i]);
            f[0][i] = f[0][i - 1];
            f[1][i] = f[1][i - 1];
            f[a[i]][i]++;
        }
        f[0][n + 1] = f[0][n];
        f[1][n + 1] = f[1][n];
        g[0].head = 1;
        g[0].val = -1;
        top = 0;
        for (i = 1; i <= n; i++) {
            idx = i;
            tmp1 = a[i];
            while (top >= 0 && g[top].val > tmp1) {
                idx = g[top].head;
                tmp1 = 1.0 * (f[1][i] - f[1][idx - 1]) / (i - idx + 1);
                top--;
            }
            top++;
            g[top].head = idx;
            g[top].val = tmp1;
        }
        ans = 0;
        g[top + 1].head = n + 1;
        for (i = 1; i <= top; i++) {
            tmp1 = g[i].val;
            num = f[0][g[i + 1].head - 1] - f[0][g[i].head - 1];
            ans += tmp1 * tmp1 * num;
            num = f[1][g[i + 1].head - 1] - f[1][g[i].head - 1];
            ans += (1.0 - tmp1) * (1.0 - tmp1) * num;
        }
        printf("%.6f\n", ans);
    }
    return 0;
}

HDU 4925 Apple Tree

题意:n*m的格子  要么种苹果  要么施化肥  施肥后的格子的相邻格子如果种了苹果  则苹果数翻倍  问最多产生几个苹果

思路:明显就是按矩形黑白染色的方法来种树和施肥  那么枚举两种情况  即是黑格子还是白格子种苹果  最后取max

代码:

#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;

int t, n, m;

int main() {
    int i, j, ans, res, k;
    scanf("%d", &t);
    while (t--) {
        scanf("%d%d", &n, &m);
        res = ans = 0;
        for (i = 1; i <= n; i++) {
            for (j = 1; j <= m; j++) {
                k = 1;
                if (i + 1 <= n)
                    k *= 2;
                if (i - 1 >= 1)
                    k *= 2;
                if (j + 1 <= m)
                    k *= 2;
                if (j - 1 >= 1)
                    k *= 2;
                if ((i + j) & 1)
                    ans += k;
                else
                    res += k;
            }
        }
        printf("%d\n", max(ans, res));
    }
    return 0;
}

HDU 4927 Series1

题意:一个序列A  每次根据这个方程ai=ai+1-ai使整个序列数字个数-1  问n-1次操作后剩下哪个数

思路:水题  只要把式子化简即可  注意高精度

代码:

import java.io.*;
import java.util.*;
import java.math.*;

public class Main {
    public static void main(String[] args) {
        Scanner cin = new Scanner(System.in);
        int t, n, T, i, j;
        BigInteger[] a = new BigInteger[3010];
        BigInteger[] c = new BigInteger[3010];
        T = cin.nextInt();
        for (t = 1; t <= T; t++) {
            n = cin.nextInt();
            c[0] = BigInteger.ONE;
            for (i = 1; i <= n; i++)
                c[i] = c[i - 1].multiply(BigInteger.valueOf(n - i)).divide(
                        BigInteger.valueOf(i));
            for (i = 1; i <= n; i++)
                a[i] = cin.nextBigInteger();
            BigInteger ans;
            ans = BigInteger.ZERO;
            int sign = 1;
            for (j = n; j >= 1; j--) {
                if (sign == 1) {
                    ans = ans.add(a[j].multiply(c[n - j]));
                    sign = -1;
                } else {
                    ans = ans.subtract(a[j].multiply(c[n - j]));
                    sign = 1;
                }
            }
            System.out.println(ans);
        }
        cin.close();
    }
}

HDU 4930 Fighting the Landlords

题意:斗地主- -b  如果一下把手牌出光就算赢  或者  你出一次对手管不上就算赢  问能不能赢

思路:模拟题…  细心就好   逻辑如下

先看是否一次能出完  如果不能  判断大小王  在自己手里必胜在别人手里必输

如果还没有结果   判炸弹  如果还没结果  就分所有能出牌的可能判断

代码:

#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;

int kind[10][5];
int cas, flag;
char str[20];
int p1[20], p2[20], vis[20], only[10][5];

int change(char x) {
	if (x == 'Y')
		return 17;
	else if (x == 'X')
		return 16;
	else if (x == '2')
		return 15;
	else if (x == 'A')
		return 14;
	else if (x == 'K')
		return 13;
	else if (x == 'Q')
		return 12;
	else if (x == 'J')
		return 11;
	else if (x == 'T')
		return 10;
	else
		return x - '0';
}

bool cmp(int a, int b) {
	return a > b;
}

int main() {
	int i, j, len1, len2;
	scanf("%d", &cas);
	getchar();
	while (cas--) {
		memset(kind, -1, sizeof(kind));
		memset(only, 0, sizeof(only));
		flag = 0;
		gets(str);
		len1 = strlen(str);
		for (i = 0; i < len1; i++) {
			p1[i] = change(str[i]);
		}
		gets(str);
		len2 = strlen(str);
		for (i = 0; i < len2; i++) {
			p2[i] = change(str[i]);
		}
		sort(p1, p1 + len1, cmp);
		sort(p2, p2 + len2, cmp);

		//7
		if (len1 >= 2 && p1[0] == 17 && p1[1] == 16) {
			kind[7][1] = 1;
			//    printf("1\n");
			printf("Yes\n");
			continue;
		}
		if (len2 >= 2 && p2[0] == 17 && p2[1] == 16) {
			kind[7][2] = 1;
			if (len2 == 2)
				only[7][2] = 1;
		}

		//8
		for (i = 3; i < len1; i++) {
			if (p1[i - 3] == p1[i - 2] && p1[i - 2] == p1[i - 1]
					&& p1[i - 1] == p1[i]) {
				kind[8][1] = p1[i];
				if (len1 == 4) {
					//    printf("2\n");
					printf("Yes\n");
					flag = 1;
				}
				break;
			}
		}
		if (flag)
			continue;
		for (i = 3; i < len2; i++) {
			if (p2[i - 3] == p2[i - 2] && p2[i - 2] == p2[i - 1]
					&& p2[i - 1] == p2[i]) {
				kind[8][2] = p2[i];
				if (len2 == 4)
					only[8][2] = 1;
				break;
			}
		}
		if ((kind[8][1] > kind[8][2]) && (kind[7][2] == -1)) {
			//    printf("3\n");
			printf("Yes\n");
			continue;
		}

		//1
		kind[1][1] = p1[0];
		kind[1][2] = p2[0];
		if (len1 == 1) {
			//    printf("4\n");
			printf("Yes\n");
			continue;
		}
		if (kind[1][1] != -1 && kind[1][1] >= kind[1][2]) {
			if ((kind[7][2] == -1) && (kind[8][2] == -1)) {
				//    printf("5\n");
				printf("Yes\n");
				continue;
			}
		}

		//2
		for (i = 1; i < len1; i++) {
			if (p1[i - 1] == p1[i]) {
				kind[2][1] = p1[i];
				if (len1 == 2)
					only[2][1] = 1;
				break;
			}
		}
		if (only[2][1]) {
			//printf("6\n");
			printf("Yes\n");
			continue;
		}
		for (i = 1; i < len2; i++) {
			if (p2[i - 1] == p2[i]) {
				kind[2][2] = p2[i];
				break;
			}
		}
		//printf("2....%d %d\n",kind[2][1],kind[2][2]);
		if (kind[2][1] != -1 && kind[2][1] >= kind[2][2]) {
			if ((kind[7][2] == -1) && (kind[8][2] == -1)) {
				//printf("7\n");
				printf("Yes\n");
				continue;
			}
		}

		//3
		for (i = 2; i < len1; i++) {
			if (p1[i - 1] == p1[i] && p1[i - 2] == p1[i - 1]) {
				kind[3][1] = p1[i];
				if (len1 == 3)
					only[3][1] = 1;
				break;
			}
		}
		if (only[3][1]) {
			//printf("8\n");
			printf("Yes\n");
			continue;
		}
		for (i = 2; i < len2; i++) {
			if (p2[i - 1] == p2[i] && p2[i - 2] == p2[i - 1]) {
				kind[3][2] = p2[i - 1];
				break;
			}
		}
		if (kind[3][1] != -1 && kind[3][1] >= kind[3][2]) {
			if ((kind[7][2] == -1) && (kind[8][2] == -1)) {
				//printf("9\n");
				printf("Yes\n");
				continue;
			}
		}
		//4
		for (i = 2; i < len1; i++) {
			if (p1[i - 1] == p1[i] && p1[i - 2] == p1[i - 1]) {
				if ((i + 1 < len1 && p1[i + 1] != p1[i])
						|| (i + 2 < len1 && p1[i + 2] != p1[i])
						|| (i - 3 >= 0 && p1[i - 3] != p1[i])
						|| (i - 4 >= 0 && p1[i - 4] != p1[i])) {
					kind[4][1] = p1[i];
					if (len1 == 4)
						only[4][1] = 1;
					break;
				}
			}
		}
		if (only[4][1]) {
			printf("Yes\n");
			continue;
		}
		for (i = 2; i < len2; i++) {
			if (p2[i - 1] == p2[i] && p2[i - 2] == p2[i - 1]) {
				if ((i + 1 < len2 && p2[i + 1] != p2[i])
						|| (i + 2 < len2 && p2[i + 2] != p2[i])
						|| (i - 3 >= 0 && p2[i - 3] != p2[i])
						|| (i - 4 >= 0 && p2[i - 4] != p2[i])) {
					kind[4][2] = p2[i];
					break;
				}
			}
		}
		if (kind[4][1] != -1 && kind[4][1] >= kind[4][2]) {
			if ((kind[7][2] == -1) && (kind[8][2] == -1)) {
				printf("Yes\n");
				continue;
			}
		}

		//5
		memset(vis, 0, sizeof(vis));
		for (i = 2; i < len1; i++) {
			if (p1[i - 1] == p1[i] && p1[i - 2] == p1[i - 1]) {
				vis[i - 2] = 1;
				vis[i - 1] = 1;
				vis[i] = 1;
				for (j = 1; j < len1; j++) {
					if ((!vis[j - 1]) && (!vis[j]) && p1[j] == p1[j - 1]) {
						kind[5][1] = p1[i];
						if (len1 == 5)
							only[5][1] = 1;
						break;
					}
				}
				vis[i - 2] = 0;
				vis[i - 1] = 0;
				vis[i] = 0;
				if (kind[5][1] != -1)
					break;
			}
		}
		if (only[5][1]) {
			printf("Yes\n");
			continue;
		}
		memset(vis, 0, sizeof(vis));
		for (i = 2; i < len2; i++) {
			if (p2[i - 1] == p2[i] && p2[i - 2] == p2[i - 1]) {
				vis[i - 2] = 1;
				vis[i - 1] = 1;
				vis[i] = 1;
				for (j = 1; j < len2; j++) {
					if ((!vis[j - 1]) && (!vis[j]) && p2[j] == p2[j - 1]) {
						kind[5][2] = p2[i];
						break;
					}
				}
				vis[i - 2] = 0;
				vis[i - 1] = 0;
				vis[i] = 0;
				if (kind[5][2] != -1)
					break;
			}
		}
		if (kind[5][1] != -1 && kind[5][1] >= kind[5][2]) {
			if ((kind[7][2] == -1) && (kind[8][2] == -1)) {
				printf("Yes\n");
				continue;
			}
		}
		//6
		for (i = 3; i < len1; i++) {
			if (p1[i - 3] == p1[i - 2] && p1[i - 2] == p1[i - 1]
					&& p1[i - 1] == p1[i]) {
				if (len1 >= 6) {
					kind[6][1] = p1[i];
					if (len1 == 6)
						only[6][1] = 1;
					break;
				}
			}
		}
		if (only[6][1]) {
			printf("Yes\n");
			continue;
		}
		for (i = 3; i < len2; i++) {
			if (p2[i - 3] == p2[i - 2] && p2[i - 2] == p2[i - 1]
					&& p2[i - 1] == p2[i]) {
				if (len2 >= 6) {
					kind[6][2] = p2[i];
					break;
				}
			}
		}
		if (kind[6][1] != -1 && kind[6][1] >= kind[6][2]) {
			if ((kind[7][2] == -1) && (kind[8][2] == -1)) {
				printf("Yes\n");
				continue;
			}
		}
		printf("No\n");
	}

	return 0;
}

2014多校联合六(HDU 4923 HDU 4925 HDU 4927 HDU 4930),布布扣,bubuko.com

时间: 2024-10-07 14:47:07

2014多校联合六(HDU 4923 HDU 4925 HDU 4927 HDU 4930)的相关文章

【HDU】4923 Room and Moor(2014多校第六场1003)

Room and Moor Time Limit: 12000/6000 MS (Java/Others)    Memory Limit: 262144/262144 K (Java/Others)Total Submission(s): 263    Accepted Submission(s): 73 Problem Description PM Room defines a sequence A = {A1, A2,..., AN}, each of which is either 0

2014多校联合三 (HDU 4888 HDU 4891 HDU 4893)

HDU 4891 The Great Pan 签到题  他怎么说你就怎么做就好了  注意做乘法时候会爆int 代码: #include<iostream> #include<cstdio> #include<cstring> #include<algorithm> using namespace std; typedef long long LL; int n; char s[2000000]; int flag1, flag2, sp, ansflag;

2014多校联合五(HDU 4911 HDU 4915 HDU 4920)

HDU 4911 Inversion 题意:n个数字  通过k次相邻交换  使得逆序对数最少 思路:如果序列为 XXXABYYY  假设A和B位置互换  易知X和AB.Y和AB的逆序对数不变  换句话说一次交换最多使逆序对减少1  那么只需要求原逆序对数和k进行比较即可 代码: #include<cstdio> #include<cstring> #include<algorithm> using namespace std; #define N 100100 type

2014多校第六场 1005 || HDU 4925 Apple Tree

题目链接 题意 : 给你一块n×m的矩阵,每一个格子可以施肥或者是种苹果,种一颗苹果可以得到一个苹果,但是如果你在一个格子上施了肥,那么所有与该格子相邻(指上下左右)的有苹果树的地方最后得到的苹果是两倍,如果(i,j)有一颗苹果树,(i-1,j)与(i,j+1)施了肥,那么苹果应该是1的两倍2,2的两倍4,最后是4个苹果,问你怎么安排苹果和施肥的格子使最后得到的苹果最多. 思路 : 画了图就可以看出来,苹果和苹果,肥与肥之间不要相邻就好了,所有的苹果之间都有施肥,所有施肥的格子都被苹果隔开了才能

2014多校联合八(HDU 4945 HDU 4946 HDU 4948 HDU 4950 HDU 4951 HDU 4952)

HDU 4945 2048 题意:给你一堆数字  问有几个子集可以拼出2048 思路: 拼数字的规则相当于让数字乘二  所以不是2^i的数字不会拼出2048  那么这些数可选可不选  即为2^cnt种可能 之后只要计算出有几个子集不可能拼出2048即可  不过简单的直接dp是2048*100000的复杂度的  会TLE 所以要变成先枚举元素  再枚举该种元素个数  再枚举2048种状态  然后利用组合求(组合里需要逆元) 为什么这样快?  因为比如枚举2^5这个元素的时候  最多取2^6个  枚

2014多校联合四(HDU 4901 HDU 4902 HDU 4905)

HDU 4901 The Romantic Hero 题意: 一串数字a  找一个位置分开  前面为S'后面为T'  从这两个集合中分别选出子集S和T  使得S中元素的"异或"值等于T中元素的"且"值  问一共几种方案 思路: 由于a[i]只有1024  那么无论怎么运算都不可能大于2047  又因为S和T有一个明显的分界  所以我们可以想到利用dp分左右两边处理  令l[i][j]表示从左到i位置且一定选取a[i]的情况下异或值为j的方案数  r[i][j]类似

2014多校第六场 || HDU 4927 Series 1(杨辉三角组合数)

题目链接 题意 : n个数,每操作一次就变成n-1个数,最后变成一个数,输出这个数,操作是指后一个数减前一个数得到的数写下来. 思路 : 找出几个数,算得时候先不要算出来,用式子代替,例如: 1 2 3 4 5 6 (2-1) (3-2) (4-3) (5-4)(6-5) (3-2-2+1)(4-3-3+2)(5-4-4+3)(6-5-5+4) (4-3-3+2-3+2+2-1)(5-4-4+3-4+3+3-2)(6-5-5+4-5+4+4-3) (5-4-4+3-4+3+3-2-4+3+3-2

2014多校联合七(HDU 4937 HDU 4938 HDU 4939 HDU 4941)

好几天没写题解了- 都怪我太弱  补题补不动- HDU 4937 Lucky Number 题意:一个数字如果只有3456这四种数字组成  那么这个数字是幸运的  问  给出一个x  它在几种进制下是幸运的  如果无穷输出-1 思路: 分类讨论  如果x是3或4或5或6  那么一定有无穷个进制满足(从十进制开始-)  直接输出-1 除去上述情况  那么我们可以将一个数字写成这样 a0 + a1*base + a2*base^2 +... = x 那么如果base的最高次只有1次或2次时  就是简

2014多校第六场 1010 || HDU 4930 Fighting the Landlords (模拟)

题目链接 题意 : 玩斗地主,出一把,只要你这一把对方要不了或者你出这一把之后手里没牌了就算你赢. 思路 : 一开始看了第一段以为要出很多次,实际上只问了第一次你能不能赢或者能不能把牌出尽. 1 #include <cstdio> 2 #include <cstring> 3 #include <iostream> 4 5 using namespace std ; 6 7 char str1[20],str2[20] ; 8 int hash1[20],hash2[2