POJ挑战赛3(POJ Challenge Round 3)题解

A. table

题目链接: http://poj.openjudge.cn/practice/1059/
有a张三角形桌子和b张正方形桌子，以及有n个小组，每个小组有Si个学生。一个小组可以选出一些桌子拼在一起供他们使用，且一个拼起来的桌子块周围能坐下的最多的人数为这个桌子块的周长。问最多能使多少个小组的人全部坐下。

1 <= N <= 10000，0 <= A, B <= 10^6，1 <= Si <= 10^6，输入数据组数小于等于10。

a张三角形桌子和b张正方形桌子的总周长为a*3 + b*4, 每拼一次的代价是-2. 所以a张三角形桌子和b张正方形桌子能拼出来的最大周长为a*3 + b*4 - 2*(a + b - 1) = a + 2*b + 2。

对{Si}从小到大排序，对于当前处理的Si, ai, bi, 如果ai + 2*bi + 2 < Si，那么记录答案退出。

否则，"尽量"用正方形桌子来满足。即如果Si为偶数，都用正方形桌子来满足，如果Si为奇数，则用1个三角形桌子和其他正方形桌子来满足。

正方形桌子用完了以后再全部用三角形桌子来满足。

原因很简单，因为每用一个三角形桌子能满足的周长+1，每用一个正方形桌子能满足的周长+2。用正方形桌子可能会浪费。

时间复杂度为排序复杂度O(nlogn)，空间复杂度O(n)。

#include <cstdio>
#include <algorithm>

using namespace std;

const int N = 10010;

int s
;

bool check(int cur, int a, int b) { return a + 2*b + 2 >= cur; }

int gao(int cur, int &a, int &b) {
if (!check(cur, a, b)) return 0;
if (a == 0) {
b -= (cur/2);
if (cur % 2 == 0) b++;
} else if (b == 0) {
a -= (cur - 2);
} else {
int curb = min((cur - 2)/2, b), cura = cur - 2*curb - 2;
a -= cura; b -= curb;
}
return 1;
}

int main() {
int a, b, n;
while (~scanf("%d%d%d", &n, &a, &b)) {
for (int i = 0; i < n; i++) {
scanf("%d", s + i);
}
sort(s, s + n);
int ans = 0;
for (int i = 0; i < n; i++) {
ans += gao(s[i], a, b);
}
printf("%d\n", ans);
}
return 0;
}

B. modseq

题目链接: http://poj.openjudge.cn/practice/1060/

给定一个长度为n的数列，然后m次询问，每次给出三个数l, r和P，询问(a[l'] + a[l' + 1] + ... + a[r']) mod P的最小值，其中l <= l' <= r' <= r。

1 <= n, m <= 100000, 1 <= l <= r <= n, 1 <= P <= 100, 0 <= a[i] <= 10^9。

初看以为是个线段树的题，想了一会没有思路。后来突然想起一个鸽巢原理的经典定理:

长度为m的序列中存在连续的一段使得这段的和能被m整除。

有了这个定理，那么对于长度大于等于P的区间，直接输出0。

对于长度小于P的区间，由于P <= 100，直接暴力求解即可。

时间复杂度O(n + m*P^2)，空间复杂度O(n)。

#include <cstdio>
#include <algorithm>

using namespace std;

const int N = 100010;
const int INF = 0x3f3f3f3f;

int n, m;
int a
;

int main() {
while (~scanf("%d%d", &n, &m)) {
for (int i = 0; i < n; i++) {
scanf("%d", a + i);
}
for (int j = 0; j < m; j++) {
int l, r, p;
scanf("%d%d%d", &l, &r, &p);
l--; r--;
if (r - l + 1 >= p) {
printf("0\n");
} else {
int ret = INF;
for (int len = 1; len <= r - l + 1; len++) {
int now = 0;
for (int i = 0; i < len; i++) {
now = (now + a[i + l]) % p;
}
ret = min(now, ret);
for (int i = len + l; i <= r; i++) {
now = (now - a[i - len] % p + a[i] + p) % p;
ret = min(now, ret);
}
}
printf("%d\n", ret);
}
}
}
return 0;
}

C. logic

题目链接:http://poj.openjudge.cn/practice/1061/

给出n个命题之间，m个"蕴含"关系。问哪些命题必须为假。

1 <= n <= 1000, 1 <= m <= 100000。

当场一直在想O(m)的算法...没想到O(nm)的算法就能过...

命题i为假的三种情况:

1. 如果命题i为真时推出矛盾，那么命题i必须为假。

2. 如果存在某个命题j, 使得命题j无论为真或假时都推出命题i为假，那么命题i必须为假。

3. 如果存在某个必须为假的命题j能推出命题i为假，那么命题i必须为假。

先对情况1,2处理出一些必须为假的命题，放到队列里。然后处理队列里的每个元素。

如果发现有没有处理过的假命题，就将其加入队列中，一直处理直到队列为空。

处理情况1,2的复杂度为O(nm)。因为最多只有n个假命题，所以处理情况3的复杂度也为O(nm)。

总的时间复杂度为O(nm)。

#include <cstdio>
#include <cstring>
#include <queue>
#include <vector>

using namespace std;

const int N = 2010;
const int M = 100010;

struct Edge { int v, next; }e[M];

int n, m;
int head
, tot;
int vis
[2];
int zero
;

void init() {
memset(zero, 0, sizeof zero);
memset(head, 0xff, sizeof head);
tot = 0;
}

void addedge(int u, int v) {
e[tot].v = v; e[tot].next = head[u]; head[u] = tot++;
}

int dfs(int u, int op) {
vis[u][op] = 1;
for (int j = head[u]; ~j; j = e[j].next) {
int v = e[j].v;
if (vis[v^1][op]) return 1;
if (vis[v][op]) continue;
if (dfs(v, op)) return 1;
}
return 0;
}

int main() {
while (~scanf("%d%d", &n, &m)) {
init();
for (int i = 0; i < m; i++) {
int x, y, ox, oy;
scanf("%d%d%d%d", &x, &y, &ox, &oy);
x--; y--; x *= 2; y *= 2;
addedge(x^ox, y^oy);
}
for (int i = 0; i < 2*n; i += 2) {
memset(vis, 0, sizeof vis);
dfs(i, 0);
if (dfs(i + 1, 1)) { zero[i] = 1; }
for (int j = 0; j < 2*n; j += 2) {
if (vis[j][0] && vis[j][1]) {
zero[j] = 1;
}
}
}
queue<int> q;
for (int i = 0; i < 2*n; i += 2) {
if (zero[i]) { q.push(i); }
}
while (!q.empty()) {
int u = q.front(); q.pop();
memset(vis, 0, sizeof vis);
dfs(u, 0);
for (int i = 0; i < 2*n; i += 2) {
if (vis[i][0]) {
if (!zero[i]) { q.push(i); }
zero[i] = 1;
}
}
}
vector<int> ans;
for (int i = 0; i < 2*n; i += 2) {
if (zero[i]) {
ans.push_back(i/2 + 1);
}
}
printf("%d\n", ans.size());
if (ans.size()) {
printf("%d", ans[0]);
for (int i = 1; i < ans.size(); i++) {
printf(" %d", ans[i]);
}
}
putchar(10);
}
return 0;
}

D. calc

题目链接: http://poj.openjudge.cn/practice/1062/
求长度为n的me number的个数。不考虑前导0。

me numbe
aea3
r满足的性质: 奇数位数字的乘积和偶数位数字的乘积相等。

2 <= n <= 50。

乘积相等有两种情况:

1. 奇数位上至少有1个0且偶数位上至少有1个0。

2. 所有位上都没有0，且奇数位上的乘积和偶数位上的乘积分解质因数后各个质因数的个数分别相等。

第一种情况简单用乘法公式算一下就行。

第二种情况，可以考虑用cnt[a][i][j][k][l]表示长度为a的数字，乘积分解后有i个2，j个3，k个5，l个7的种类数。

初始情况为cnt[0][0][0][0][0] = 1。

对于n为偶数的情况，种类数就是sum(cnt[n/2][i][j][k][l]^2), 对于所有的i, j, k, l。

对于n为奇数的情况，种类数就是sum(cnt[(n+1)/2][i][j][k][l]*cnt[n/2][i][j][k][l])，对于所有的i, j, k, l。

最后结果就是情况1的种类数加上情况2的种类数。

因为内存限制，这里要用滚动数组优化一下空间。

时间复杂度O(n^5)，空间复杂度O(n^4)。

#include <cstdio>
#include <cstring>

const int N = 26;
const int MOD = 2999;

int ans[N*2];
int cnt[2][N*3][N*2]

;
int pow9
, C

;

void init() {
pow9[0] = 1;
for (int i = 1; i < N; i++) {
pow9[i] = pow9[i-1]*9 % MOD;
}
C[0][0] = 1;
for (int i = 1; i < N; i++) {
C[i][0] = 1;
for (int j = 1; j <= i; j++) {
C[i][j] = (C[i-1][j] + C[i-1][j-1]) % MOD;
}
}
}

int count0(int len) {
int ret = 0;
for (int i = 1; i <= len; i++) {
ret = (ret + C[len][i]*pow9[len-i]) % MOD;
}
return ret;
}

void change(int now, int i, int j, int k, int l) {
int &cur = cnt[now][i][j][k][l];
cur = cnt[now^1][i][j][k][l];
if (i >= 1) cur += cnt[now^1][i-1][j][k][l];
if (j >= 1) cur += cnt[now^1][i][j-1][k][l];
if (i >= 2) cur += cnt[now^1][i-2][j][k][l];
if (k >= 1) cur += cnt[now^1][i][j][k-1][l];
if (i >= 1 && j >= 1) cur += cnt[now^1][i-1][j-1][k][l];
if (l >= 1) cur += cnt[now^1][i][j][k][l-1];
if (i >= 3) cur += cnt[now^1][i-3][j][k][l];
if (j >= 2) cur += cnt[now^1][i][j-2][k][l];
cur %= MOD;
}

void gao() {
memset(cnt, 0, sizeof cnt);
cnt[0][0][0][0][0] = 1;
for (int p = 1, now = 0; p < N; p++) {
now ^= 1;
for (int i = 0; i <= p*3; i++) {
for (int j = 0; j <= p*2; j++) {
for (int k = 0; k <= p; k++) {
for (int l = 0; l <= p; l++) {
change(now, i, j, k, l);
}
}
}
}
int n = 2*p - 1;
for (int m = 0; m < 2; m++) {
ans[n+m] = 9*count0((n+m)/2)*count0((n+m)/2 - (n+m+1) % 2) % MOD;
}
for (int i = 0; i <= p*3; i++) {
for (int j = 0; j <= p*2; j++) {
for (int k = 0; k <= p; k++) {
for (int l = 0; l <= p; l++) {
int odd = cnt[now][i][j][k][l];
for (int m = 0; m < 2; m++) {
int even = cnt[now^(m^1)][i][j][k][l];
ans[n+m] = (ans[n+m] + odd*even) % MOD;
}
}
}
}
}
}
}

int main() {
init(); gao();
int n;
while (~scanf("%d", &n)) {
printf("%d\n", ans
);
}
return 0;
}

允许转载，转载请注明出处: http://blog.csdn.net/lkjslkjdlk/article/details/15953549