BlogJava-[NKU]sweet ＠ ICPC || TopCoder ||Other-随笔分类-ACM/ICPC

2011ACM福州网络预选赛 F HDU4068 三国杀

[NKU]sweet — Fri, 07 Oct 2011 12:15:00 GMT

题意很简单……双方给N个人（N<=6）打三国杀1V1，你知道对手每个人能克制你哪些人，我们认为两个人对打，他能克你则他胜利，否则你胜利；某人的N个人死光就输了……你需要组织阵容按照顺序对抗对手……求有没有一个顺序，无论对手顺序如何，你都能胜……
N！枚举自己的顺序，然后N！枚举对方的顺序，O（N）验证即可……
注意字典序最小……

1 #include <cstdio>
2 #include <cstring>
3 #include <string>
4 #include <map>
5 #include <algorithm>
6 #include <iostream>
7
8 using namespace std;
9
10 map<string,int> mp;
11 int n;
12 int res[10];
13 int my[10];
14 char buf[50];
15 char name[10][50];
16 string ans;
17
18 void check() {
19     int enemy[] = {0,1,2,3,4,5,6,7,8,9};
20     do {
21         int i = 0;
22         int j = 0;
23         while (i < n && j < n) {
24             if ((1 << my[i]) & res[enemy[j]]) i ++; else j++;
25         }
26         if (i == n) return;
27     } while (next_permutation(enemy,enemy + n));
28     string tmp;
29     for (int i = 0; i < n; i++) {
30         if (i) tmp += " ";
31         tmp += name[my[i]];
32     }
33     if (ans == "" || ans > tmp) ans = tmp;
34 }
35
36 int main() {
37     int nn; scanf("%d",&nn);
38     for (int ii = 1; ii <= nn; ii++) {
39         mp.clear();
40         memset(res,0,sizeof(res));
41         scanf("%d",&n);
42         for (int i = 0; i < n; i++) {
43             scanf("%s",name[i]);
44             mp[string(name[i])] = i;
45         }
46         for (int i = 0; i < n; i++) {
47             int m; scanf("%d",&m);
48             for (int j = 0; j < m; j++) {
49                 scanf("%s",buf);
50                 int tmp = mp[string(buf)];
51                 res[i] |= 1 << tmp;
52             }
53         }
54         for (int i = 0; i < n; i++) {
55             my[i] = i;
56         }
57         ans = "";
58         do {
59             check();
60         } while (next_permutation(my,my + n));
61         printf("Case %d: ",ii);
62         if (ans == "") {
63             puts("No");
64         } else {
65             puts("Yes");
66             for (int i = 0; i < ans.length(); i++) putchar(ans[i]);
67             putchar(10);
68         }
69     }
70     return 0;
71 }

[NKU]sweet 2011-10-07 20:15 发表评论

2011ACM北京网络预选赛 F Machine scheduling (BUPT 216)

[NKU]sweet — Sun, 18 Sep 2011 14:56:00 GMT

这题比赛时候过得很纠结……最后还是学长过的……比赛时候脑子可能不够清楚，一直WA……
首先，这个题要分成两个部分解决：
第一部分：从n个东西里面取出r个，每个间距至少为 k （1～K不行，1～K ＋ 1行）
第二部分：将这r个东西分成至多m组，可以有空组
第二部分貌似好久之前搞OI的时候干过……贴过来：

N球放在M个盒子里，求共有多少种放法

但是有3个不同的条件：N个球是否相同，M个盒子是否相同，是否允许有盒子空着

球和球	盒和盒	空盒	情况数
有区别	有区别	有空盒	mⁿ
有区别	有区别	无空盒	M！s（n,m）
有区别	无区别	有空盒	S(n,1)+s(n,2)+…+s(n,m),n>=m S(n,1)+s(n,2)+…+s(n,n),n<=m
有区别	无区别	无空盒	S(n,m)
无区别	有区别	有空盒	C(n+m-1,n)
无区别	有区别	无空盒	C(n-1,m-1)
无区别	无区别	有空盒	F(m,n)
无区别	无区别	无空盒	F(m,n-m)

然后，其中的F(m,n)貌似是当时写过的一个DP，S(M,N)是第二类stirling数……
递推公式：

1 int S(int n,int m) {
2 if (n == m || m == 1) return 1;
3 return m * S(n - 1, m) + S(n - 1, m - 1);
4 }

第一部分：可以看作这么一个生成函数的相关问题：由于每个东西之间都隔了>=K－1的一段距离，因此一个可行解可以看作，长度为K，K + 1，K + 2的棍子r － 1个（我们认为每个棍子的头是我们取的点），拼接成长度为Len的一个大段，之后再堵上一个，就是一个Len ＋１的可行解……
而r - 1根棍子，拼成长度为Len 的可行解数目，就是(X^K + X^(K + 1) + X^(K + 2) + .....) ^ (r - 1)，这个多项式，展开之后，X^Len项前面的系数……
不过……由于数据范围，直接搞是不成的……
于是提取，变形：X^(K * (r - 1)) * (1 + X + X^2 + X ^3 +....)^(r - 1)
然后再变形：X^(K * (r - 1)) * (1/(1 - x))^(r - 1)……
然后参照Matrix67大神的日志，展开后面那项：

1/(1-x)^n=1+C(n,1)x^1+C(n+1,2)x^2+C(n+2,3)x^3+...+C(n+k-1,k)x^k+...

我们知道，要求长度为len的可行数目，也就是要X^Len项前面的系数，然后，由于前面提取出来了一个K * (r - 1)，也就是去后面找len - K * (r - 1) 项的系数……
也就是说，令pow = len - K * (r - 1)，答案就是C(r - 1 + pow - 1, pow)……
不过这还没完，因为咱们要拼成的长度是len，而总的长度是N，需要乘上这个长度len的开头位置的可能数……
另外还需要特殊处理：咱们在处理的时候，是先用r - 1个拼接成长度为Len的一个大段，再堵上最后一个……当r == 1需要特判……
代码：

1 #include <cstdio>
2 #include <cstring>
3
4 typedef long long Long;
5 const Long MOD = 1000000007;
6
7 Long F[1010][1010];
8 Long C[2010][2010];
9 Long S(int n,int m) {
10     if (n == m || m == 1) return 1LL;
11     if (F[n][m] > 0) return F[n][m];
12     return F[n][m] = (m * S(n - 1, m) % MOD + S(n - 1, m - 1)) % MOD;
13 }
14 void init() {
15     for (int i = 0; i <= 2000; i++) {
16         for (int j = 0; j <= i; j++) {
17             if (j == 0) C[i][j] = 1;
18             else C[i][j] = (C[i - 1][j] + C[i - 1][j - 1]) % MOD;
19         }
20     }
21 }
22 int n,r,k,m;
23
24 int main() {
25     memset(F,0xff,sizeof(F));
26     init();
27     while (scanf("%d%d%d%d",&n,&r,&k,&m) > 0) {
28         if (r == 1) {printf("%d\n",n); continue;}
29         Long ans = 0;
30         for (int i = 1; i <= m && i <= r; i++) {
31             ans = (ans + S(r,i)) % MOD;
32         }
33         Long tmp = 0;
34         for (int len = k * (r - 1); len < n; len++) {
35             int left = n - len;
36             int pow = len - k * (r - 1);
37             // r > 1 !!
38             tmp = (tmp + left * C[r - 1 + pow - 1][pow]) % MOD;
39         }
40         ans = ans * tmp % MOD;
41         printf("%lld\n",ans);
42     }
43     return 0;
44 }

[NKU]sweet 2011-09-18 22:56 发表评论

旁门左道第二章之障碍器

[NKU]sweet — Wed, 06 Apr 2011 04:36:00 GMT

原文： Java线程：新特征-障碍器，这是该作者的原创作品，允许转载，转载时请务必以超链接形式标明文章原始出处、作者信息和本声明。否则他将追究法律责任……

Hmm……好怕怕，转个日志都会被追究法律责任……

不过要感谢原文的兰州，在兰州的文章帮助下，今天突然发现了灵感，改造了改造兰州的代码……
在ACM中的作用，我觉得可以这样：
1：对于单文件多case的题，开多线程，每个线程跑一个case，之后再调用收尾的任务输出
2：对于单case且可以并行的情况，开若干线程处理之后，调用收尾函数來最后处理、输出

以下是一个简单的求和代码，实际效果，在我的双核CPU上用时大概减少了一半

1 import java.util.concurrent.BrokenBarrierException;
2 import java.util.concurrent.CyclicBarrier;
3
4 public class Test {
5     public static int[] ans;
6     void run() {
7         ans = new int[4];
8         int now = 0;
9         for (int i = 0; i < 400000000; i++) {
10             now = (now + i) % 9999997;
11         }
12         System.out.println(now);
13         CyclicBarrier cb = new CyclicBarrier(4, new MainTask());
14         new SubTask(0,0,100000000,cb).start();
15         new SubTask(1,100000000,200000000,cb).start();
16         new SubTask(2,200000000,300000000,cb).start();
17         new SubTask(3,300000000,400000000,cb).start();
18     }
19     public static void main(String[] args) {
20         new Test().run();
21     }
22 }
23
24 class MainTask implements Runnable {
25     public void run() {
26         int ans = 0;
27         for (int i = 0; i < 4; i++) {
28             ans = (ans + Test.ans[i]) % 9999997;
29         }
30         System.out.println(ans);
31     }
32 }
33
34 class SubTask extends Thread {
35     private int pos;
36     private int left;
37     private int right;
38     private CyclicBarrier cb;
39     final int mod = 9999997;
40
41     SubTask(int pos,int left,int right,CyclicBarrier cb) {
42         this.pos = pos;
43         this.left = left;
44         this.right = right;
45         this.cb = cb;
46     }
47
48     public void run() {
49         int ans = 0;
50         for (int i = left; i < right; i++) {
51             ans = (ans + i) % mod;
52         }
53         Test.ans[pos] = ans;
54
55         try {
56             cb.await();
57         } catch (InterruptedException e) {
58             e.printStackTrace();
59         } catch (BrokenBarrierException e) {
60             e.printStackTrace();
61         }
62     }
63 }

[NKU]sweet 2011-04-06 12:36 发表评论

贴个裸模板……求引玉……

[NKU]sweet — Wed, 23 Feb 2011 06:32:00 GMT

1 import java.util.*;
2 import java.io.*;
3 import java.math.*;
4
5
6 class Main {
7     public static void main(String args[]) throws IOException {
8         new Prob().solve();
9     }
10 }
11
12 class Prob {
13     void solve() throws IOException {
14         MyReader in = new MyReader();
15         //.
16     }
17     void debug(Objectx) {
18         System.out.println(Arrays.deepToString(x));
19     }
20 }
21
22 class MyReader {
23     BufferedReader br = new BufferedReader (
24         new InputStreamReader (System.in));
25     StringTokenizer in;
26     String next() throws IOException {
27   while (in == null || !in.hasMoreTokens()) {
28             in = new StringTokenizer(br.readLine());
29         }
30         return in.nextToken();
31     }
32     int nextInt() throws IOException {
33         return Integer.parseInt(next());
34     }
35 }

[NKU]sweet 2011-02-23 14:32 发表评论