Codeforces 375

A

　　7的所有的余数都可以用1，6，8，9排列得到，然后搞一下就可以了。

B

　　可以用类似于单调队列的东西搞。具体看代码：

/* 
 * Problem: B. Maximum Submatrix 2
 * Author: Shun Yao
 * Note: 题目要求交换行，我写的交换列。于是把矩阵转换一下就可以。
 */

#include <string.h>
#include <stdlib.h>
#include <limits.h>
#include <assert.h>
#include <stdio.h>
#include <ctype.h>
#include <math.h>
#include <time.h>

#include <map>
#include <set>
#include <list>
#include <stack>
#include <queue>
#include <deque>
#include <string>
#include <vector>
#include <bitset>
#include <utility>
#include <iomanip>
#include <numeric>
#include <sstream>
#include <iostream>
#include <algorithm>
#include <functional>

//using namespace std;

const int MAXN = 5010, MAXM = 5010;

int n, m, a[MAXN][MAXM], f[MAXN][MAXM];
char s[MAXN][MAXM];

int main(/*int argc, char **argv*/) {
	int i, j, k, l, ans;
	
//	freopen("B.in", "r", stdin);
//	freopen("B.out", "w", stdout);
	
	scanf("%d%d", &n, &m);
	for (i = 1; i <= n; ++i)
		scanf(" %s", s[i] + 1);
	ans = 0;
	for (i = 1; i <= n; ++i) {
		a[0][i] = i;
		f[0][i] = 0;
	}
	for (i = 1; i <= m; ++i) {
		l = 0;
		for (j = 1; j <= n; ++j) {
			k = a[i - 1][j];
			if (s[k][i] == '1') {
				f[i][k] = f[i - 1][k] + 1;
				a[i][++l] = k;
				ans = std::max(ans, f[i][k] * l);
			} else
				f[i][k] = 0;
		}
		for (j = 1; j <= n; ++j)
			if (f[i][j] == 0)
				a[i][++l] = j;
	}
	printf("%d", ans);
	
	fclose(stdin);
	fclose(stdout);
	return 0;
}

 C

　　题目中实际上有提示，用dp[i][j][k]表示在(i, j)，过所有object的射线的奇偶性为k的最小步数。

/* 
 * Problem: C. Circling Round Treasures
 * Author: Shun Yao
 */

#include <string.h>
#include <stdlib.h>
#include <limits.h>
#include <assert.h>
#include <stdio.h>
#include <ctype.h>
#include <math.h>
#include <time.h>

#include <map>
#include <set>
#include <list>
#include <stack>
#include <queue>
#include <deque>
#include <string>
#include <vector>
#include <bitset>
#include <utility>
#include <iomanip>
#include <numeric>
#include <sstream>
#include <iostream>
#include <algorithm>
#include <functional>

//using namespace std;

const int MAXN = 22, MAXM = 22, dx[4] = {0, 0, 1, -1}, dy[4] = {1, -1, 0, 0};

int n, m, a[MAXN][MAXM], sum[333], f[MAXN][MAXM][333];
char s[MAXN][MAXM];

class Data {
public:
	int x, y, k;
	Data(int X, int Y, int K) : x(X), y(Y), k(K) {}
} ;

std::queue<Data> q;

int main(/*int argc, char **argv*/) {
	int bomb, object, tl, i, j, k, x, y, trea[10], treasure[10], sx, sy, xx, yy, kk, ans;
	
	scanf("%d%d", &n, &m);
	for (i = 1; i <= n; ++i)
		scanf(" %s", s[i] + 1);
	bomb = 0;
	object = 0;
	tl = 0;
	for (i = 1; i <= n; ++i)
		for (j = 1; j <= m; ++j) {
			switch (s[i][j]) {
			case 'B':
				++object;
				bomb += 1 << (object - 1);
				for (k = 1; k <= i; ++k)
					a[k][j] += 1 << (object - 1);
				break;
			case 'S':
				s[i][j] = '.';
				sx = i;
				sy = j;
				break;
			case '.':
				break;
			case '#':
				break;
			default:
				++tl;
				++object;
				trea[s[i][j] - '0'] = 1 << (object - 1);
				for (k = 1; k <= i; ++k)
					a[k][j] += 1 << (object - 1);
			}
		}
	for (i = 1; i <= tl; ++i)
		scanf("%d", &treasure[i]);
	for (i = 0; i < 1 << object; ++i)
		if ((i & bomb) == 0)
			for (j = 1; j <= tl; ++j)
				if (i & trea[j])
					sum[i] += treasure[j];
	//bfs-----------------------------------------------------------------------
	memset(f, -1, sizeof f);
	f[sx][sy][0] = 0;
	q.push(Data(sx, sy, 0));
	ans = 0;
	while (!q.empty()) {
		x = q.front().x;
		y = q.front().y;
		k = q.front().k;
		q.pop();
		if (x == sx && y == sy)
			ans = std::max(ans, sum[k] - f[x][y][k]);
		for (i = 0; i < 4; ++i) {
			xx = x + dx[i];
			yy = y + dy[i];
			if (xx < 1 || xx > n || yy < 1 || yy > m || s[xx][yy] != '.')
				continue;
			kk = k;
			if (i == 0)
				kk ^= a[xx][yy];
			if (i == 1)
				kk ^= a[x][y];
			if (f[xx][yy][kk] == -1) {
				f[xx][yy][kk] = f[x][y][k] + 1;
				q.push(Data(xx, yy, kk));
			}
		}
	}
	printf("%d", ans);
	
	fclose(stdin);
	fclose(stdout);
	return 0;
}

D

　　启发式合并平衡树 或者 莫队算法(其实dfs后分块做也可以）。

E

　　官方给的是线性规划。dp也可以过。

转载于:https://www.cnblogs.com/hsuppr/p/3508150.html