C++博客-wolf5x@bupt-随笔分类-acm_icpc

pku 3697 USTC campus network O(M)

Sun, 14 Aug 2011 19:06:00 GMT

08合肥网赛某题。
http://poj.org/problem?id=3697
题意是问在N个点的完全图(N<=10,000)中删掉M(M<=1,000,000)条边后, 还有多少个点与顶点1连通(顶点编号从1开始).
暴力BFS+HASH+各种WS优化的方法很多, 但是出题人原意应该是O(M)的做法吧... 下面是我YY出来的O(M)的做法.

只考虑这M条待删边, 能得到什么信息呢? 可以先从点1入手. 扫一遍与1邻接的点, 那么剩下没被扫到的点肯定与1是连通的. 而被扫到的点是"有可能"与1不连通. 所以就把那些肯定与1连通的点做标记. 从这些确定连通的点中任选一个u, 再扫描它的所有邻接点. 这之后, 如果一个点一共被扫了2次, 那么它才"有可能"与1不连通, 其它少于2次的点肯定与1连通, 因为它或者与1连通, 或者与u连通, 而u是已知与1连通的. 这样再拿出一个已经确定连通的点, 扫描它的邻接点, 把被扫过次数<3的又标记为已连通......

经过上面的YY, 算法基本上就出来了:
把已知肯定与1连通的点集称为S, 剩下不确定的为T. 一开始, S中只有1这一个点, 其它点都在T中. 每个点有个计数器, 记录自己被扫了多少次.
1) 从S中取出一个没处理过的点, 把它标记为已处理, 并遍历它的所有邻接点, 被遍历到的点的计数器都+1.
2) T中所有"计数3) 重复1), 直到S中所有点都处理完.
这时, S中的点就是与1连通的, T中剩下的就是不连通的.

复杂度分析:
读入边和扫描边都是O(M)的.
S集可以用队列维护, 总共O(N).
T集的维护: 每一轮都要扫一遍当前的T, 把所有计数小的删掉, 放进S中. 这样, 这一步的总复杂度就是O(sigma(T)), 会不会到达O(N^2)呢? 实际上是不会的. 因为一条边最多只会使一个顶点的计数+1, 因此每一轮还剩在T中的点数不会超过这一轮遍历过的边数. 这样, 所有回合的sigma(T)就肯定不会超过总边数. 因此这里总共也是O(M)的. 严格来说算上第1轮有N-1个点, 也是O(M+N).
这样总的复杂度就是O(M)了.

不过这个算法读入用scanf时, g++跑了1000+ms, 改成getchar才到200+ms的. 不知道排前面的神们是不是有更NB的算法.

代码:

 1 #include 
 2 #include 
 3 #include 
 4 #include 
 5 #include 
 6 using namespace std;
 7 
 8 const int MAXN = 10010;
 9 const int MAXM = 1000010;
10 
11 struct Edge {
12     int v, next;
13 }edg[MAXM*2];
14 int ecnt, gg[MAXN];
15 bool yes[MAXN];
16 int que[MAXN], pq, sq, cnt[MAXN], vt[MAXN], nt;
17 int N, M;
18 
19 inline int getnextint()
20 {
21     int r = 0;
22     char c;
23     while(!isdigit(c=getchar())); 
24     do{
25         r = r*10 + c-'0';
26     } while(isdigit(c=getchar()));
27     return r;
28 }
29 
30 inline void addedge(int u , int v)
31 {
32     edg[ecnt].v = v; edg[ecnt].next = gg[u], gg[u] = ecnt++;
33     edg[ecnt].v = u; edg[ecnt].next = gg[v], gg[v] = ecnt++;
34 }
35 
36 int main()
37 {
38     int cas = 0;
39     while(~scanf("%d%d", &N, &M) && !(N==0 && M==0)){
40         
41         ecnt = 0;
42         for(int i = 0; i < N; i++){
43             gg[i] = -1;
44             yes[i] = i==0 ? true : false;
45             cnt[i] = 0;
46             vt[i] = i+1;
47         }
48         nt = N-1;
49         
50         for(int i = 0; i < M; i++){
51             int u = getnextint();
52             int v = getnextint();
53             addedge(--u, --v);
54         }
55         
56         pq = sq = 0;
57         que[sq++] = 0;
58         yes[0] = true;
59         
60         while(pq != sq) {
61             int u = que[pq++];
62             for(int e = gg[u]; e >= 0; e = edg[e].next) {
63                 if(!yes[edg[e].v])
64                     cnt[edg[e].v]++;
65             }
66             for(int i = 0; i < nt; i++) {
67                 while(i < nt && cnt[vt[i]] < pq) {
68                     yes[vt[i]] = true;
69                     que[sq++] = vt[i];
70                     if(i < --nt) 
71                         vt[i] = vt[nt];
72                 }
73             }
74         }
75         printf("Case %d: %d\n", ++cas, sq-1);
76         
77     }
78     return 0;
79 }

wolf5x 2011-08-15 03:06 发表评论

有向有环图的最小路径覆盖

Tue, 19 Jul 2011 14:42:00 GMT

本文纯属YY……

今天多校联合训练三的C题，http://acm.hdu.edu.cn/showproblem.php?pid=3861，题意归结起来是在一个有向图中求最小路径覆盖，也就是用尽量少的链去覆盖整个图，每个顶点必须属于且只能属于一条链。但是题意并未说明原图无环。标程解法是强连通分量缩点，再求有向无环图的最小路径覆盖。反例是：1->2,2->3,4->5,5->6,2->5,5->2。正解是2，123一组，456一组。

因为是要求路径数最小，所以YY了一个上下界最小流的做法。构图是将原来的点A0拆成两个，A和A'。从A到A'连一条边，下界和上界都为1。所有原来A0的出边，都从A'出去，下界0，上界1.所有原来A0的入边，都指向A。新建一个源点S，一个汇点T。从S到每个点A连一条边，下界0，上界1。从每个A'到T连一条边，下界0，上界1。

对这个新图求最小流，即为原题所求。

YY的证明：
A->A'，限制了这个点必须经过一次。这条边上的流量有两个来源：其它的点B'，或者源点S，前者说明A和B在同一条链中，B是A的前驱，后者说明A是链的起点。同样，这个流量有两个去处：其它的点C'，或者汇点T，前者说明A和C在同一条链中，C是A的后继，后者说明A是链的终点。

到达汇的每1单位流量，意味着一条链的终结。所以最小流就能让链数最少。

YY完毕，欢迎开炮……

ps. 理论上说，以上方法肯定是错的。要不然求Hamiltion通路就不是NP了＠。＠

wolf5x 2011-07-19 22:42 发表评论

hdu 3311 steiner tree / 状态压缩spfa

Thu, 27 May 2010 08:21:00 GMT

http://acm.hdu.edu.cn/showproblem.php?pid=3311

给定6个基础点，和1000个辅助点，以及无向边若干。
求一棵代价最小的生成子树，使得6个基础点连通。
http://en.wikipedia.org/wiki/Steiner_tree_problem

方法一：
状态DP。
一棵树，实际上可以看成是由两棵子树拼接而成，或者一棵树扩展一条边筛选。而要完整地表示一棵子树，需要记录它的根，和对6个基础点的覆盖状态。
这样求一棵大树，可以枚举接合点，以及两个子树的覆盖状态。
若dp[i][j]，i表示接合点，j表示覆盖状态，那么dp[i][j]=min{dp[i][k]+dp[i][j^k]}。
直接扩展一条边, 可以在保持j不变的情况下, 优先队列广搜, 大大降低复杂度.

方法二：
spfa。
dp[i][j]意义同上。一个点(i,j)，对每个邻接点i'，枚举那一头的状态j'，然后用dp[i][j]+dp[i'][j']+way[i][i']去更新dp[i][j|j']和dp[i'][j|j']。

ps. topcoder srm 470 div1 level3是此题升级版.

  1 #include <string>
  2 #include <vector>
  3 #include <list>
  4 #include <map>
  5 #include <queue>
  6 #include <stack>
  7 #include <set>
  8 #include <iostream>
  9 #include <sstream>
 10 #include <numeric>
 11 #include <algorithm>
 12 #include <cmath>
 13 #include <cctype>
 14 #include <cstdlib>
 15 #include <cstdio>
 16 #include <cstring>
 17 using namespace std;
 18 
 19 #define CLR(x) memset((x),0,sizeof(x))
 20 #define SET(x,y) memset((x),(y),sizeof(x))
 21 #define REP(i,x) for(int i=0;i<(x);i++)
 22 #define FOR(i,x,y) for(int i=(x);i<(y);i++)
 23 #define VI vector 
 24 #define PB(i,x) (i).push_back(x)
 25 #define MP(x,y) make_pair((x),(y))
 26 
 27 struct EDGE{
 28     int v,e,d;
 29 }edg[20000];
 30 int ecnt, gg[1006];
 31 
 32 struct HEAP{
 33     int v,d;
 34     void set(int nv, int nd){v=nv;d=nd;}
 35 }hp[1006*(1<<6)*10];
 36 int sz;
 37 bool vis[1006];
 38 
 39 int dp[1006][1<<6];
 40 int N, M, P;
 41 
 42 bool cmp(const HEAP &a, const HEAP &b)
 43 { return a.d>b.d; }
 44 
 45 void addedge(int u, int v, int d)
 46 {
 47     edg[ecnt].v=v; edg[ecnt].d=d; edg[ecnt].e=gg[u]; gg[u]=ecnt++;
 48     edg[ecnt].v=u; edg[ecnt].d=d; edg[ecnt].e=gg[v]; gg[v]=ecnt++;
 49 }
 50 
 51 int steiner()
 52 {
 53     int up = 1<<(N+1);
 54     SET(dp,-1);
 55     REP(i,N+1) dp[i][1<<i]=0;
 56     FOR(i,N+1,N+M+1) dp[i][0]=0;
 57     REP(i,up){
 58         REP(j,N+M+1){
 59             for(int k=i; k>0; k=(k-1)&i){
 60                 if(dp[j][k]!=-1 && dp[j][i^k]!=-1)
 61                     if(dp[j][i]==-1 || dp[j][i]>dp[j][k]+dp[j][i^k])
 62                         dp[j][i]=dp[j][k]+dp[j][i^k];
 63             }
 64         }
 65         sz=0;
 66         CLR(vis);
 67         REP(j,N+M+1) if(dp[j][i]!=-1){
 68             hp[sz++].set(j,dp[j][i]);
 69             push_heap(hp, hp+sz, cmp);
 70         }
 71         while(sz){
 72             int now=hp[0].v;
 73             pop_heap(hp, hp+sz--,cmp);
 74             if(vis[now])continue;
 75             vis[now]=true;
 76             for(int e=gg[now]; ~e; e=edg[e].e){
 77                 int to=edg[e].v, td=dp[now][i]+edg[e].d;
 78                 if(dp[to][i]==-1 || dp[to][i]>td){
 79                     dp[to][i]=td;
 80                     hp[sz++].set(to,td);
 81                     push_heap(hp, hp+sz, cmp);
 82                 }
 83             }
 84         }
 85     }
 86     return dp[0][up-1];
 87 }
 88 
 89 int main()
 90 {
 91     while(~scanf("%d %d %d", &N, &M, &P)){
 92         int u, v, d;
 93         SET(gg,-1); ecnt=0;
 94         REP(i,N+M){
 95             scanf("%d", &d);
 96             addedge(0,i+1, d);
 97         }
 98         REP(i,P){
 99             scanf("%d %d %d", &u, &v, &d);
100             addedge(u,v,d);
101         }
102         int ret=steiner();
103         printf("%d\n", ret);
104     }
105     return 0;
106 }

wolf5x 2010-05-27 16:21 发表评论

Two Professors (CERC 2008) 解题报告

Thu, 24 Dec 2009 06:34:00 GMT

Two Professors
CERC 2008

题目大意:给n条线段,要求划分成尽可能少的子集,使得在同一个子集中的线段两两不重叠.
同时限定线段1和线段2不能在同一子集中.

记每条线段为[Li,Ri], 每个子集的最右端为Bi.
记线段1和2中,L较小的那个为X,另一个为Y.

如果没有那个限定,容易想到贪心的方法:将所有线段按L从小到大排序.然后依次处理线段k,如果当前存在某个集合的Bi<=Lk,就将Lk加入此集合中,并更新Bi=Rk.否则新开一个集合放入k.模拟这个过程,最后的集合数就是答案.用堆维护已有集合的信息,时间复杂度是O(nlgn).

有了限制条件后,原方法不适用了,因为在X与Y之间处理的线段,对Y有后效性.这会使得单纯按照刚才的方法随意贪心,可能轮到Y时,只有X所在集合的Bi<=LY,迫使必须开新集合.但实际上,有可能可以通过调整X与Y之间的线段排列结构,使Y避开X.
问题关键就是如何判断能否调整(并不用关心详细的调整步骤).
当一条线段(P)面临多个可插入的集合时,之前的方法是随意选一个,而不合适的决策正在此产生.下面构造一个情景:
假设P可以在两个集合s,t中选择,而X在s中.
现在P选择加入t.
接下来按部就班地处理.
轮到Y选时,它只能选择加入s,或者开新的集合.
这时候,我们能得知,如果当初P选择的是s,紧随其后的其它选择也相应地对调,那么Y此时肯定面临的是只能加入t,或者开新的集合.
这样Y当然直接加入t就行了.
这说明,只要存在一个这样的P,当Y遭遇X时,肯定存在形状对称的另一个局面使Y避开X,而P就是关键先生.

所以只需稍微改造之前的算法,在处理X与Y之间的线段时,判断并记录下是否出现过可选局面.这样就能正确处理Y遭遇X的情形了.
其它情形时策略不变(可以证明这样的解是最优的).

代码略...

wolf5x 2009-12-24 14:34 发表评论

Guarders: Maximal Cliques on Circular-arc Graph

Mon, 07 Sep 2009 05:23:00 GMT

Maximal Cliques on Circular-arc Graph
合肥2008现场赛, 2009网赛 Guarders
In graph theory, a circular-arc graph is the intersection graph of a set of arcs on the circle. --wiki

uestc_floyd的做法是搜+剪枝.

zzh@bupt大牛想出二分图匹配的做法:
固定某个区间Li肯定选中, 则剩下的区间里, 可能被选择的只有与Li有交集的那些.
(*)将那些区间分两类: 与Li的左边界交的, 与Li的右边界交的.
易知与Li两边界都交的是肯定可以选的, 不会产生不合要求的局面.
不合要求的情况只可能是, 某个一类区间和某个二类区间没有交, 却同时选了它们.
所以二分图建图方法为, 若某个一类区间和某个二类区间没有交, 则连一条边.
二分图的顶点数+1-最大匹配数即为Li对应的最优解.
枚举每个Li.
理论时间复杂度相当高, O(n)*O(匹配), 实现上可以加入排序, 最优解剪枝等方案.

ps. (*)非常巧妙的想法! 非常艺术!

wolf5x 2009-09-07 13:23 发表评论

pku 2114 Boatherds (树的分治)

Fri, 31 Jul 2009 06:30:00 GMT

摘要: 题目给出一棵树(N<=10000)以及所有边的权(<=10000). 现在要求对任意查询Q(<=10^8), 判断是否存在一条边权之和恰好为Q的路径.标程的方法暂时没看懂= =... 我用树的分治做(更多相关内容见09国家集训队漆子超的论文)考虑一棵以root为根的子树, 那么在这棵子树中, 有多少条 v1->root->v2 的路径长恰好为Q呢?... 阅读全文

wolf5x 2009-07-31 14:30 发表评论

pku 3450 Corporate Identity (后缀数组,KMP扩展,自动机)

Fri, 31 Jul 2009 05:46:00 GMT

后缀数组,KMP扩展,自动机
题目要求4000个长度为200的字串的最长公共子串.
只需选一个串作为基串, 枚举它的所有后缀串S[i..len], 求出其它串与这个子串的LCP. 最后选最大的输出.
关于求串S与串T所有后缀的LCP, 林希德的论文讲了扩展KMP算法. 不过我想出另一种方法:
把S和T直接连接得到新串U. 按正常KMP的方法求U的next数组, 不过当p指向U[len[S]+1]即原T串的首字母时, 直接将此位的next置为0.
最后min(len[S], next[k]) 就是串T[1..(k-len[S])]与串S的lcp长度.

代码如下:

1#include <iostream>
2using namespace std;
3
4char wd[4000][201];
5int cnt[201][201], vis[201][201];
6char ss[401];
7int next[401];
8int N;
9
10bool readin()
11{
12  scanf("%d",&N);
13  if(N==0)return false;
14
15  for(int i=0; i<N; i++)
16    scanf("%s",wd[i]);
17  return true;
18}
19
20int mycmp(char *s1, int l1, char *s2, int l2)
21{
22  if(l1!=l2) return (l2-l1);
23  while(--l1 && *s1==*s2) s1++, s2++;
24  return (*s1-*s2);
25}
26
27void mycpy(char *s1, char *s2, int l)
28{
29  while(l--) *(s1++)=*(s2++);
30  *s1=0;
31}
32
33void solve()
34{
35  memset(cnt,0,sizeof(cnt));
36  memset(vis,0,sizeof(vis));
37
38  int l0=strlen(wd[0]);
39  strcpy(ss,wd[0]);
40  char ans[201]="";
41
42  for(int p=0; p<l0; p++){
43    char *s=&ss[p];
44    for(int i=1; i<N; i++){
45      strcpy(&ss[l0], wd[i]); //连接两个串
46      int l1=l0-p+strlen(wd[i]);
47      next[0]=-1;
48      int p0=-1, p1=0;
49      while(p1<l1){
50        while(p0>=0 && s[p0]!=s[p1])
51          p0=next[p0];
52        next[++p1]=++p0;
53        if(p1==l0-p) //此位置0
54          next[p1]=0, p0=0;
55        if(p1>=l0-p){
56          int len=min(l0-p, next[p1]);
57          if(vis[p][p+len-1]!=i)
58            vis[p][p+len-1]=i, cnt[p][p+len-1]++;
59        }
60      }
61    }
62
63    for(int j=l0-1; j>=p; j--){
64      if(cnt[p][j]==N-1){
65        if(mycmp(&ss[p], j-p+1, ans, strlen(ans))<0)
66          mycpy(ans, &ss[p], j-p+1);
67      }
68    }
69  }
70
71  if(ans[0]==0)
72    puts("IDENTITY LOST");
73  else
74    puts(ans);
75}
76
77int main()
78{
79  while(readin()){
80    solve();
81  }
82}
83

wolf5x 2009-07-31 13:46 发表评论

几道线性的题目

Thu, 16 Jul 2009 12:12:00 GMT

几道线性的题目

Tanks a Lot
题意:
一个圆,周长为整数n(n<=10^7).圆周上有k(k<=n)个加油站,每个加油站有整数的油量w[i],所有加油站总油量恰好为n. 行车单位路程耗油量为1, 车的初始油量为0. 问,以哪些加油站为起点可以走完一周? 分别判断顺时针和逆时针的情况.
解:
栈的应用.
考虑单个点v1,沿路径v1,v2,v3,...走,则从v1能完成一周的充要条件是对任意的k,S[1,k-1]-C[1,k]>=0,其中S[1,k-1]为这段路上总加油量,C[1,k]为总耗油量.
再考虑先后2个点vk1,vk2. 设沿路径vk1,vp1,vp2,...,vk2,...vpm走.如果vk1和vk2都能到达vpm,肯定vk1必需先能够达到vk2. 这说明从vk1到vpm时的剩余油量肯定>=vk2到vpm时的剩余油量. 有了这个单调性,再加上油余量的区间性以及区间可合并性, 就可以维护一个单调的栈.栈中顶点的访问次序递增,剩余油量递减且不小于0.正扫一遍反扫一遍分别判断顺时针和逆时针.

A Walk in the Park
题意:
二维平面上有一些(N<=10^5)无限长的水平线和竖直线(M<=10^5), 以及一些不在线上的点. 人可以沿任意线走.
称某个点是可见的, 当且仅当人能站在某条线上, 以垂直于线的方向正对此点,并且人与点的连线上没有其它点阻碍视线.
求可见的点的个数.
解:
排序+离散化+线性扫描; 二分
先考虑能否从水平线上看到某个点.
将点按y坐标排序.
对同一x上的所有点,考虑不是起始或末尾的相邻的两个点,它们能被看到,当且仅当它们之间有直线.
这样可以把直线也按y排序, 顺序扫一遍.对某个坐标x,记录它上一个点的y值.
离散化和排序都是nlogn的, 但是线性扫描的思路很巧,值得注意.
直接二分更简单,对每对相邻的点,二分查找它们之间是否有线段.

wolf5x 2009-07-16 20:12 发表评论

uva4031 Integer Transmission (DP)

Thu, 16 Jul 2009 11:28:00 GMT

uva4031 Integer Transmission (DP)
题意:
传送一个长度在64之内的01串,第i时刻发送出第i字节(i=0,1,...,L-1).对任意第i时刻发出的字节,它有可能在i+1,i+2,...,i+d+1(d<=L)中的任一时刻到达接收端.当同一时刻有多个字节同时到达时,这些字节可以任意排列.
问接收端可能收到多少种不同串? 并求出二进制最小的和最大的串.
按位DP, 关键是确定前i位至多能有多少个0/1,至少必须有多少个0/1. 此题与windy's abc很相似, 但多了处变化.
考虑 d=3, 原串为 1101011, 显然第1个1永远不可能跑到第2个0右边. 字符串的错位,本质上是某些1把它右边d之内的0挤到左边了. 因此对1, 它实际能向右移多少位,取决于它右边d之内有多少个0.
这样预处理后按位DP即可.
构造最小/最大数,只需尽量把1/0往低位扔就行了.

代码:

  1 #include <iostream>
  2 #include <cstdio>
  3 #include <cstdlib>
  4 #include <cstring>
  5 #include <algorithm>
  6 #include <cmath>
  7 using namespace std;
  8 
  9 typedef unsigned long long ull;
 10 
 11 int mi[2][130], mx[2][130];
 12 ull dp[65][65];
 13 int b[65];
 14 int N,D;
 15 ull K;
 16 int CAS;
 17 
 18 void init()
 19 {
 20     int i,j,k;
 21     ull t;
 22     memset(b,0,sizeof(b));
 23     for(t=K, i=N; t; i--){
 24         b[i] = t&1;
 25         t>>=1;
 26     }
 27     int c[2][130];
 28     memset(c,0,sizeof(c));
 29     for(i=1; i<=N; i++)
 30         c[b[i]][i]++;
 31     for(i=N; i>=1; i--)
 32         c[0][i] += c[0][i+1], c[1][i] += c[1][i+1];
 33     memset(mi, 0, sizeof(mi));
 34     memset(mx, 0, sizeof(mx));
 35     for(i=1; i<=N; i++){
 36         mx[b[i]][ min(N, i+c[b[i]^1][i+1]-c[b[i]^1][i+D+1]) ] ++;
 37     }
 38     for(i=N; i>=1; i--){
 39         mx[0][i] += mx[0][i+1];
 40         mx[1][i] += mx[1][i+1];
 41         mi[0][i] = max(0, N+1-i-mx[1][i]);
 42         mi[1][i] = max(0, N+1-i-mx[0][i]);
 43     }
 44 }
 45 
 46 ull dodp()
 47 {
 48     int i,j,k,p;
 49     ull ret = 0;
 50     memset(dp,0,sizeof(dp));
 51     for(i=0; i<=N; i++)
 52         dp[N][i] = 1;
 53     for(p=N; p>=1; p--){
 54         for(i=mi[0][p]; i<=mx[0][p]; i++){
 55             j=N+1-p-i;
 56             if(j<mi[1][p] || j>mx[1][p]) continue;
 57             if(dp[p][i]==0)continue;
 58             if(p==1){ ret += dp[p][i]; continue; }
 59             dp[p-1][i] += dp[p][i];
 60             dp[p-1][i+1] += dp[p][i];
 61         }
 62     }
 63     return ret;
 64 }
 65 
 66 void getans(ull &xx, ull &ii)
 67 {
 68     int i,j,k;
 69     int c0[2][65],c1[2][65];
 70     memset(c0,0,sizeof(c0));
 71     memset(c1,0,sizeof(c1));
 72     for(i=1; i<=N; i++){
 73         if(b[i]==0)
 74             c0[0][i]++, c1[0][min(N,i+D)]++;
 75         else
 76             c1[1][i]++, c0[1][min(N,i+D)]++;
 77     }
 78     //for(i=1; i<=N; i++
 79     xx = ii = 0;
 80     for(i=1; i<=N; i++){
 81         while(c0[0][i]--) ii = (ii<<1);
 82         while(c0[1][i]--) ii = (ii<<1)|1;
 83         
 84         while(c1[1][i]--) xx = (xx<<1)|1;
 85         while(c1[0][i]--) xx = (xx<<1);
 86     }
 87 }
 88 
 89 void solve()
 90 {
 91     int i,j,k;
 92     printf("Case %d: ", ++CAS);
 93     printf("%llu ", dodp());
 94     ull xx,ii;
 95     getans(xx, ii);
 96     printf("%llu %llu\n", ii, xx);
 97 }
 98 
 99 int main()
100 {
101     CAS = 0;
102     while(scanf("%d",&N)!=EOF && N){
103         scanf("%d %llu",&D,&K);
104         init();
105         solve();
106     }
107 }
108 

wolf5x 2009-07-16 19:28 发表评论

字符串匹配后缀数组 trie图(更新)

Thu, 16 Jul 2009 11:10:00 GMT

字符串少量习题小结.

spoj694(易) 后缀数组
求一个字串的不同子串个数.
按rank考虑子串.加入子串S[i]时,获得了len-Sa[i]个不同子串.但其中height[i]个已经属于S[i-1]了,所以实际子串数增加了len-Sa[i]-S[i-1]. 顺序扫一遍height数组即得解.

spoj687(中) 后缀数组
求一个串的重复次数最多的连续重复子串.
设周期为L的连续重复子串存在,则点0,L,2L,...,kL必能覆盖到一个完整周期. 因此对L,考察这些点的字符相等情况,LCP情况,可得到L的解.
枚举L.
复杂度是O(n/1+n/2+...+n/n) = O(nlogn)

pku3693(中) 后缀数组
同spoj687,只是结果还要输出字典序最小的满足条件的串.可以借助rank数组直接比较字典序.只是要注意在考察点kL时,要把以(k-1)L+1,...,(k+1)L-1为起点的子串都访问一遍找最小rank者.

pku1743(中) 后缀数组
找一个串的最长不重叠相同子串.
由于某子串可能整体加上(或减去)相同偏移量,因此不直接对原串操作,而是构造新串b, 其中b[i]=a[i]-a[i-1]. 此时求得最长不重叠相同子串的长度+1便是结果.
可以二分长度,或者栈扫描(*)直接求最大长度.

whu1084(易) 后缀数组
求重复次数最多的不重叠子串长度
spoj687的简单版,不要求循环节连续,直接二分长度即可.

pku2778(易) 多串匹配+DP AC自动机,trie图
字符集大小为4, 给出m个(m<=10)禁止单词(长度<=10), 求长度为n(n<=2*10^9)的不包含任何禁止单词的串的个数.
对禁止单词建立trie图,并计算出图中任意合法结点之间的转移数,这样便求得1步转移矩阵.
做n次方后的矩阵,第1行中属于合法状态的元素之和即为解.
禁止单词总长度不超过100,因此合法状态亦<100.总复杂度100^3*logN

zju3228(中) Searching the String 后缀数组,AC自动机,trie图
原串长10^5, 现在有10^5次查询, 每次查询一个长度<=6的模式串在原串中的最大匹配次数.
模式串的匹配方式有可重叠和不可重叠两种, 需针对查询的类型返回相应值.
后缀数组解法(在线):
对原串建立sa和height数组.由于模式串长度最大只有6, 我们可以将height数组分别按L=1..6分组,预处理求出相应长度每组内不重叠子串的最大匹配次数,此过程O(6*nlogn).
另外由于sa数组将所有后缀按字典序排好了,所以对一个询问, 可以二分找到它在sa中第一次出现的位置p1和最后一次出现的位置p2, 则p2-p1+1就是可重叠匹配的答案. 对不可重叠匹配,只需直接返回p1处预处理时的值. 每次查询O(logn).
trie图,AC自动机解法(离线):
把所有查询建trie图, 对图中的每个有效结点维护:该串长度,两类查询的计数,该串上一次被匹配的位置, 还要用个链表记下这个串属于哪些查询.
剩下的就是经典的自动机多串匹配了.

(*)关于栈扫:
height数组具有区间性,各个不同前缀被相应的极小值隔开,而一个区间中又有多个子区间.各区间值大于区间端点的部分互不影响.因此可以维护一个存放height值不减的栈,栈中每个元素的附属值, 记录了它在栈中相邻的两个元素为端点的连续区间内所有height值不小于它的必要信息.比如此题要记录height>=k的连续区间内sa[i] 的最大值和最小值.
栈扫描的经典例子移步pku2559.

(**)trie图备忘:
比trie树多了个后缀指针psuf. 设当前结点字母为c, 则psuf指向父亲的后缀的pch[c].
trie树中的后代结点指针pch(已经更名为状态转移指针),当相应后代存在时,指向后代;否则指向当前结点的后缀的相应后代,即pch[k]=node[pa].pch[k].
后缀指针: 在接下来的状态转移中,当前结点与它的后缀结点等价.
后代结点指针: 在当前状态下,接收到字符ch时,转移到pch[ch]指向的结点.

wolf5x 2009-07-16 19:10 发表评论

pku 2990 Board Game (二分图匹配)

Mon, 06 Jul 2009 03:55:00 GMT

二分图匹配的巧妙应用
相当巧妙!
CTU 2005 Open
http://acm.pku.edu.cn/JudgeOnline/problem?id=2990

题意:
8*8的棋盘, 初始放置2个相同的棋子. Alice和Bob轮流行动. 每次行动可以把其中一个棋子移到它上下左右相邻格内(某些格子坏掉了,则不能移). 当某人的移动使两棋子重合时, 他赢. 另, 一局中不能出现重复的局面. 比如(0,0)(4,0) -> (1,0)(4,0)合法, 此时如果再(1,0)(4,0) -> (0,0)(4,0)则非法. 当一个人无子可动时, 他输.
两人都用最优策略. 问先手的Alice必胜还是必败?

解:
把每个合法状态看成一个顶点, 则状态转移就是向其它点连边. 这样建的图是二分图.
而两人下棋, 就是在图上以初始状态的顶点为起点, 沿边移动. 由于建的图是由所有合法状态与合法移动组成的, 因此, 移动到哪个集合(A与B), 就表示轮到谁行动. 当无法再移动时, 点在哪个集合就表示对应的人输了.
状态不重复出现, 表示移动路径没有环.
谁赢谁输, 与路径长度的奇偶性密切相关.
考虑二分图的最大匹配, 也是个找交替路径扩张的过程.

设起点为v, 分情况讨论v的状态与路径长度的关系:

(1) v是自由点. 这表示v的任意邻接点vB都是浸润点. 不管选哪个vB, 都可以沿着它的匹配边走到vA'. 只要Bob每次都沿匹配边走, 由于不可能达到另一个自由点, 因此终点必属于A, Bob必胜.

(2) v是浸润点, 此时v所在的交替路径两个端点分布情况可能有几种:
    a)对所有交替路径, 端点都在B集. 这时只要Alice每次都沿着匹配边走, 必胜.
    b)存在一条交替路径, 端点都在A集. 把沿v的匹配边走的那一半全部置反, 就变成(1)的状态了, 因此2者等价.
    c)沿v的匹配边走的那一半全终止于B, 另一半终止于A. 只要Alice一开始就沿匹配边走, 后面策略同a.
    其它情形不可能在最大匹配中出现, 故不讨论. 这正是充分利用了最大匹配的性质.

因此对本题先求最大匹配, 然后判断是否为(1)或(2b), 即可知胜负.

代码如下:

  1 #include <iostream>
  2 using namespace std;
  3 
  4 const int MAX_VERT = (1<<12)+1;
  5 const int MAX_EDGE = MAX_VERT * 16;
  6 struct EDGE{
  7     int v,e;
  8 }edg[ MAX_EDGE ];
  9 int se, gg[ MAX_VERT ], nv;
 10 int start;
 11 int mat[ MAX_VERT ];
 12 bool ok[ MAX_VERT ], vis[ MAX_VERT ];
 13 
 14 int N,M;
 15 char bo[20][20];
 16 
 17 bool chkpt(int x, int y)
 18 {
 19     if(x<0 || x>=M || y<0 || y>=N) return false;
 20     if(bo[y][x]=='#') return false;
 21     return true;
 22 }
 23 
 24 //判断合法状态 
 25 bool chksta(int x1, int y1, int x2, int y2)
 26 {
 27     if(!chkpt(x1,y1) || !chkpt(x2,y2)) return false;
 28     if(abs(x1-x2)+abs(y1-y2)<=1) return false;
 29     return true;
 30 }
 31 
 32 //位压缩存状态 
 33 int encode(int x1, int y1, int x2, int y2) 
 34 {
 35     if(y1 > y2 || (y1==y2 && x1 > x2)) //小点放前面, 避免重复状态 
 36         swap(y1,y2), swap(x1,x2);
 37     int v = x1;
 38     v = (v<<3) | y1;
 39     v = (v<<3) | x2;
 40     v = (v<<3) | y2;
 41     return v;
 42 }
 43 
 44 inline void addedge(int u, int v)
 45 {
 46     edg[se].v = v;
 47     edg[se].e = gg[u];
 48     gg[u] = se++;
 49 }
 50 
 51 void addmove(int u, int x1, int y1, int x2, int y2)
 52 {
 53     if(!chksta(x1, y1, x2, y2)) return ;
 54     int v = encode(x1, y1, x2, y2);
 55     addedge(u, v);
 56 }
 57 
 58 //添加状态转移的边 
 59 void gene(int x1, int y1, int x2, int y2)
 60 {
 61     if(!chksta(x1,y1,x2,y2)) return;
 62     int u = encode(x1,y1,x2,y2);
 63     ok[u] = true;
 64     mat[u] = -1;
 65     addmove(u, x1+1, y1, x2, y2);
 66     addmove(u, x1-1, y1, x2, y2);
 67     addmove(u, x1, y1+1, x2, y2);
 68     addmove(u, x1, y1-1, x2, y2);
 69     addmove(u, x1, y1, x2+1, y2);
 70     addmove(u, x1, y1, x2-1, y2);
 71     addmove(u, x1, y1, x2, y2+1);
 72     addmove(u, x1, y1, x2, y2-1);
 73 }
 74 
 75 //建图 
 76 void input()
 77 {
 78     int x1, y1, x2, y2;
 79     
 80     for(y1=0; y1<N; y1++)
 81         scanf("%s",bo[y1]);
 82         
 83     se = 1;
 84     memset(gg,0,sizeof(gg));
 85     nv = M << 9;
 86     memset(ok, false, sizeof(ok));
 87     memset(mat, 0xff, sizeof(mat));
 88     memset(vis, false, sizeof(vis));
 89     
 90     int c=0, tx[2],ty[2];
 91     for(y1=0; y1<N; y1++){
 92         for(x1=0; x1<M; x1++){
 93             if(bo[y1][x1] == 'P')
 94                 tx[c]=x1, ty[c]=y1, c++;
 95             for(x2=x1+1; x2<M; x2++)
 96                 gene(x1,y1,x2,y1);
 97             for(y2=y1+1; y2<N; y2++)
 98                 for(x2=0; x2<M; x2++)
 99                     gene(x1,y1,x2,y2);
100         }
101     }
102     start = encode(tx[0], ty[0], tx[1], ty[1]);
103 }
104 
105 bool hungrey(int r)
106 {
107     //这个匹配函数不分XY集, 因此匹配点双方的mat标记都要修改 
108     int i,j,k;
109     vis[r] = true;
110     for(j=gg[r]; j>0; j=edg[j].e){
111         int v = edg[j].v;
112         if(!vis[v]){
113             vis[v] = true;
114             if(mat[v]==-1 || hungrey(mat[v])){
115                 mat[v] = r;
116                 mat[r] = v;
117                 return true;
118             }
119         }
120     }
121     return false;
122 }
123 
124 int main()
125 {
126     int i,j,k;
127     while(scanf("%d %d",&N,&M)!=EOF){
128         input();
129         if( !ok[start] ){
130             puts("Alice wins.");
131             continue;
132         }
133         
134         for(i=0; i<nv; i++){
135             memset(vis, false, sizeof(vis));
136             if( mat[i]==-1 ) hungrey(i);
137         }
138         if( mat[start]!=-1 ){ //判断是否是(2b)并转化为(1) 
139             memset(vis, false, sizeof(vis));
140             vis[start] = true;
141             if(hungrey(mat[start]))
142                 mat[start] = -1;
143         }
144         
145         if( mat[start]!=-1 )
146             puts("Alice wins.");
147         else
148             puts("Bob wins.");
149     }
150     return 0;
151 }
152 

wolf5x 2009-07-06 11:55 发表评论

Nice Prefixes (DP好题)

Mon, 29 Jun 2009 14:18:00 GMT

http://acm.scs.bupt.cn/onlinejudge/showproblem.php?problem_id=1586
题意:
一共有K(K<=50)种字母,组成一个长度为L(L<=10^18)的串.
这个串需满足要求:
对任意的 1<=i<=L , 以及任意的 1<=k1,k2<=K 且 k1!=k2, 在前缀 s[1..i]中,字母k1的个数和字母k2的个数之差的绝对值<=2.
例如: abac是合法的; 而abbbc不合法, 因为前缀abbb中字母b和c的个数相差为3.
建立状态:
从<=2 入手找状态. 可以设前c个字母中, 最小个数为m, 字母数为m的种类为i, m+1的种类为j, m+2的种类为k. 化简状态可得比最小个数多1的种类为i,比最小个数多2的种类为j. 而经过数学推导(不懂), 可知 j+2k于是可以设矩阵m[i,j]为c%K=0时,k经过K步从i转移到j的方法数.
这样先求出 L-L%K 步的方法数, 最后 L%K 步直接dp即可.
整体复杂度为 K^3*log(L/K).

本题关键: 由k和c%K唯一确定i和j; 一次走K步, 消除状态c%K, 实际上不同c%K对应的状态是冗余的, 因为不用去管中间的过程.

wolf5x 2009-06-29 22:18 发表评论

第二次个人赛

Mon, 29 Jun 2009 14:11:00 GMT

E. Ski Lessons (DP)
题意:
滑雪场有N(N<=10000)种项目, 可以从任意时刻开始, 可以反复参加. 每种项目要求参与者技能值(<=100)至少为c[i], 耗费连续的d[i]单位时间.
此外,滑雪场提供S(S<=100)个培训课程. 每个课程开始时间为m[i], 持续时间l[i], 结束后, 参加者的技能值变为a[i]. 如果选择参加某个课程,不能迟到早退. 只能同时参加一个课程.
一个人在任意时刻只能做一件事, 而且他总共有 T(T<=10000) 单位时间. 他必须在时刻T结束所有活动.
问如何安排可以使得此人参加最多次滑雪项目, 求最大次数.
解:
O(100*N)预处理, len[i][j]表示技能值为i时, 参加一次任意项目的最短时间.
O(S*S)DP, dp[i]表示在课程i开始的前一时刻, 已参加项目的最大次数.
注意到, 结束一项课程后人的技能值是一定的. 因此, 可以枚举参加i之前最近参加的课程k, 两次课程之间的收益可直接计算. 则dp[i] = max(dp[k]+ (m[i]-m[k]-l[k])/len[a[k]]).

wolf5x 2009-06-29 22:11 发表评论

第一次个人赛

Mon, 29 Jun 2009 13:50:00 GMT

D.
题意:
给一个初值C,和两个迭代公式 fi(x)=a[i]*x/d[i]+b[i], 公式中1<=d由初值C开始迭代, 计算出来的结果又可以任意代入公式继续迭代.
求能得到的所有数(包括C)中第N大的. 1<=N<=400000.
解:
一个队列,两个指针,不断分别将指向的两个值代入两个公式计算,取小的加入列尾.注意判重.

G.
题意:
无向图,顶点集为U, 给一个不包含源点v的子顶点集S, 问至少要在U-S-{v}中删掉多少个点,才能完全割断S与v的联系. S中没有点与v直接相邻.
解:
限制顶点流量,最大流(最小割),将点i0拆成i->i',所有入边指向i,出边从i'指出.对有可能损坏的点,边容量置1,不可能损坏的点置inf.其它边容量为inf.

I.
题意:
给一个颜色序列s, 序列长度<=40000, 其中包含的颜色种类<=40000. 可以将原序列任意分割, 分割后每一个子段的代价分别为f(k)=k*k,其中k为子段中包含的颜色种类数.
求一个分割方案,使sigma(f(k))最小.
解:
DP.关键的优化在于,转移dp[i]时,只用枚举计算min{dp[j]+cost(j+1,i)},其中子段[j+1,i]中至多有upbound=ceil(sqrt(i))种不同颜色.因为代价函数是k^2,而长度为k的子段代价上界是k,所以枚举的颜色数<=sqrt(k).
另显然,颜色数都为m的所有可能区间[j+1,i],选择最长的肯定最优.
因此维护pos[m],表示从当前扫描位置开始向左,颜色种类为m的最长区间的左端点.
为了更新pos[m],再设数组last[n],记录上一次出现颜色n的位置.
若color[i]==color[i-1],则不更新pos; 否则,所有pos[k]>=last[color[i]]的区间内颜色种类都变成k+1,因此将这段pos[1..m]右移,将pos[1]置为i.

wolf5x 2009-06-29 21:50 发表评论

pku 3726 Windy's ABC (DP)

Mon, 29 Jun 2009 13:44:00 GMT

pku 3726 Windy's ABC
题意:
给一个由ABC三种字母构成的长度不超过500的字串.
定义这个串的合法副本为:
原串任意位置字母的下标,与它在新串中的下标绝对值之差不超过 Ri.
求合法副本的种类数.
注:
1. 原串本身也是个合法副本
2. 求的是不同串的种类数, "A1B2B3A4" 和 "A1B3B2A4" 算同一种.
解:
先通过O(n)的递推, 求出每种字母在前k位中至少需要/至多能出现多少次, 然后500^3的DP.
对一个合法的状态(i,j,k)(分别表示3种字母的个数), 扩展它的3种后续状态.
这里不用检查扩展出的新状态的合法性, 因为到下一步DP时, 只有合法的状态才会被继续扩展. 这是这题解法处理的巧妙之处.

代码:

1 #include <cstdio>
2 #include <cstdlib>
3 #include <cstring>
4 #include <algorithm>
5 using namespace std;
6 const int MOD = 20090305;
7 char ch[3] = {'A','B','C'};
8 int n[3][510][2];
9 int dp[2][510][510];
10 int R[3],L;
11 char S[510];
12 int T;
13
14 void prepare(){
15     int i,j,k;
16     int c[510];
17     memset(n,0,sizeof(n));
18     for(i=0; i<3; i++){
19         int cnt = 0;
20         for(j=0; j<L; j++){
21             if(S[j]-'A' == i) cnt++;
22             //printf("%d,%d,%d ",i,j,cnt);
23             if(j>=R[i]) n[i][j-R[i]][1] = cnt;
24             if(j<L-R[i]) n[i][j+R[i]][0] = cnt;
25         }
26         for(j=0; j<R[i]; j++){
27             n[i][L-1-j][1] = cnt;
28             n[i][j][0] = 0;
29         }
30     }
31 }
32
33 int dodp(){
34     int l,i,j,k;
35     int ans = 0;
36     memset(dp,0,sizeof(dp));
37     for(i=0; i<L; i++)
38         for(j=0; j<L; j++)
39             dp[0][i][j] = 1;
40     for(l=0; l<L; l++){
41         int p1=l%2, p2=(l+1)%2;
42         memset(dp[p2],0,sizeof(dp[p2]));
43         for(i=n[0][l][0]; i<=n[0][l][1]; i++){
44             for(j=n[1][l][0]; j<=n[1][l][1]; j++){
45                 k = l+1-i-j;
46                 //printf("s%d,%d,%d ",l,i,j);
47                 if(k<n[2][l][0] || k>n[2][l][1]) continue;
48                 if(!dp[p1][i][j]) continue;
49                 //printf("y%d,%d,%d(%d) ",l,i,j,dp[p1][i][j]);
50                 if(l==L-1){ ans += dp[p1][i][j]; continue; }
51                 dp[p2][i+1][j] = (dp[p2][i+1][j]+dp[p1][i][j]) % MOD;
52                 dp[p2][i][j+1] = (dp[p2][i][j+1]+dp[p1][i][j]) % MOD;
53                 dp[p2][i][j] = (dp[p2][i][j]+dp[p1][i][j]) % MOD;
54             }
55         }
56     }
57     return ans;
58 }
59
60 int main(){
61     int i,j,k;
62     scanf("%d",&T);
63     while(T--){
64         scanf("%d %d %d",R,R+1,R+2);
65         scanf("%s",S);
66         L = strlen(S);
67         prepare();
68         printf("%d\n",dodp());
69     }
70     return 0;
71 }
72

wolf5x 2009-06-29 21:44 发表评论

[转]frkstyc的POJ分类

Sat, 20 Jun 2009 14:30:00 GMT

frkstyc的POJ分类
zhj5825 发表于 2006-9-3 17:12:00

1474 geometry
1000 ad hoc
1003 ad hoc
1004 ad hoc
1005 ad hoc
1008 ad hoc
1023 ad hoc
1045 ad hoc
1046 ad hoc
1047 ad hoc
1079 ad hoc
1102 ad hoc
1126 ad hoc
1140 ad hoc
1207 ad hoc
1218 ad hoc
1220 ad hoc
1289 ad hoc
1306 ad hoc
1316 ad hoc
1326 ad hoc
1423 ad hoc
1450 ad hoc
1477 ad hoc
1488 ad hoc
1491 ad hoc
1493 ad hoc
1517 ad hoc
1519 ad hoc
1528 ad hoc
1552 ad hoc
1565 ad hoc
1583 ad hoc
1628 ad hoc
1635 ad hoc
1657 ad hoc
1658 ad hoc
1663 ad hoc
1665 ad hoc
1759 ad hoc
1775 ad hoc
1781 ad hoc
1809 ad hoc
1859 ad hoc
1868 ad hoc
1936 ad hoc
1942 ad hoc
1969 ad hoc
2000 ad hoc
2006 ad hoc
2013 ad hoc
2015 ad hoc
2017 ad hoc
2027 ad hoc
2083 ad hoc
2105 ad hoc
2109 ad hoc
2126 ad hoc
2136 ad hoc
2140 ad hoc
2141 ad hoc
2144 ad hoc
2159 ad hoc
2190 ad hoc
2196 ad hoc
2231 ad hoc
2249 ad hoc
2262 ad hoc
2272 ad hoc
2301 ad hoc
2305 ad hoc
2309 ad hoc
2316 ad hoc
2321 ad hoc
2328 ad hoc
2330 ad hoc
2350 ad hoc
2351 ad hoc
2379 ad hoc
2380 ad hoc
2390 ad hoc
2403 ad hoc
2419 ad hoc
1131 algebra
1707 algebra
1125 all pairs shortest paths
1375 analytical geometry
1473 analytical geometry
2098 analytical geometry
2242 analytical geometry
1001 arbitrary precision calculation
1354 arbitrary precision calculation
1454 arbitrary precision calculation
1503 arbitrary precision calculation
2389 arbitrary precision calculation
2413 arbitrary precision calculation
2240 Bellman-Ford algorithm
1195 binary indexed tree
1330 binary search
2418 binary search tree
1466 bipartite graph matching
1087 bipartite graph matching or maximum flow
2018 bisection and dynamic programming
1505 bisection and greedy
1434 bisection method
2155 bit operation or binary indexed tree
1111 breadth first search
1562 breadth first search
1724 breadth first search
1753 breadth first search
1915 breadth first search
1924 breadth first search
2225 breadth first search
2243 breadth first search
2251 breadth first search
2312 breadth first search
2386 breadth first search
2415 breadth first search
2426 breadth first search
2435 breadth first search
1209 calendar
2080 calendar
2210 calendar
1031 computational geometry
1127 computational geometry
1648 computational geometry
1654 computational geometry
1675 computational geometry
1912 computational geometry
2099 computational geometry
2150 computational geometry
2318 computational geometry
2398 computational geometry
2423 computational geometry
1032 construction
1147 construction
1148 construction
1702 construction
1844 construction
1898 construction
1906 construction
2085 construction
2319 construction
2356 construction
2402 construction
1426 construction or breadth first search
1606 construction or breadth first search
1113 convex hull
2187 convex hull and enumeration
1010 depth first search
1011 depth first search
1022 depth first search
1054 depth first search
1118 depth first search
1144 depth first search
1190 depth first search
1564 depth first search
1655 depth first search
1904 depth first search
1980 depth first search
2184 depth first search
2186 depth first search
2362 depth first search
2378 depth first search
2438 depth first search
1151 discretization and union of intervals or segment tree
1182 disjoint sets
1291 disjoint sets
1703 disjoint sets
1984 disjoint sets
2021 disjoint sets
2236 disjoint sets
2371 divide and conquer
2388 divide and conquer
1014 dynamic programming
1015 dynamic programming
1018 dynamic programming
1036 dynamic programming
1038 dynamic programming
1050 dynamic programming
1088 dynamic programming
1093 dynamic programming
1156 dynamic programming
1157 dynamic programming
1159 dynamic programming
1160 dynamic programming
1163 dynamic programming
1170 dynamic programming
1191 dynamic programming
1221 dynamic programming
1338 dynamic programming
1458 dynamic programming
1579 dynamic programming
1631 dynamic programming
1651 dynamic programming
1661 dynamic programming
1664 dynamic programming
1678 dynamic programming
1685 dynamic programming
1722 dynamic programming
1732 dynamic programming
1745 dynamic programming
1821 dynamic programming
1909 dynamic programming
1923 dynamic programming
1925 dynamic programming
1953 dynamic programming
2033 dynamic programming
2133 dynamic programming
2151 dynamic programming
2181 dynamic programming
2229 dynamic programming
2247 dynamic programming
2250 dynamic programming
2342 dynamic programming
2353 dynamic programming
2355 dynamic programming
2385 dynamic programming
2393 dynamic programming
2397 dynamic programming
2414 dynamic programming
2430 dynamic programming
2439 dynamic programming
2441 dynamic programming
2442 dynamic programming
2084 dynamic programming and arbitrary precision calculation
1387 dynamic programming and enumeration
1322 dynamic programming or generating function
1012 enumeration
1013 enumeration
1142 enumeration
1171 enumeration
1183 enumeration
1318 enumeration
1411 enumeration
1543 enumeration
1647 enumeration
1650 enumeration
1828 enumeration
1916 enumeration
1930 enumeration
2078 enumeration
2100 enumeration
2191 enumeration
2245 enumeration
2326 enumeration
2346 enumeration
2363 enumeration
2381 enumeration
2436 enumeration
2444 enumeration
1267 enumeration and bisection
1129 enumeration and depth first search
1186 enumeration and hash table
1348 enumration
1472 expression evaluation
2106 expression evaluation
2246 expression evaluation
2269 expression evaluation
2234 game theory
2348 game theory
2425 game theory
1799 geometry
1927 geometry
1939 geometry
1940 geometry
2007 geometry
2208 geometry
2276 geometry
2365 geometry
2405 geometry
1981 geometry and enumeration
1090 Gray code
1832 Gray code
1017 greedy
1042 greedy
1083 greedy
1230 greedy
1328 greedy
1456 greedy
1862 greedy
1922 greedy
2054 greedy
2082 greedy
2209 greedy
2291 greedy
2313 greedy
2325 greedy
2370 greedy
2376 greedy
2431 greedy
2433 greedy
2437 greedy
1405 greedy and arbitrary precision calculation
1659 greedy and construction
1026 group theory
1033 group theory
1286 group theory
1674 group theory
2369 group theory
2409 group theory
2366 hash table or binary search
1521 Huffman tree
1742 knapsack
2392 knapsack
1538 Lagrangian interpolation
2344 linear algebra and greedy
1462 linear systems
1914 linear systems
2440 matrix algebra
1149 maximum flow
1273 maximum flow
1459 maximum flow
2125 maximum flow and minimum cut
2377 maximum spanning tree
1258 minimum spanning tree
1679 minimum spanning tree
1861 minimum spanning tree
2421 minimum spanning tree
1166 modular systems
1222 modular systems
1681 modular systems
2345 modular systems
1905 Newton's iteration
2420 Newton's iteration
2299 number of inversions
1006 number theory
1061 number theory
1067 number theory
1152 number theory
1284 number theory
1320 number theory
1401 number theory
1455 number theory
1597 number theory
1808 number theory
1811 number theory
1845 number theory
1995 number theory
2115 number theory
2407 number theory
2417 number theory
2429 number theory and enumeration
1146 permutation
1256 permutation
1731 permutation
1833 permutation
2079 rotating calipers
2104 search
1177 segment tree
2182 segment tree
2352 segment tree or binary indexed tree
1016 simulation
1028 simulation
1048 simulation
1049 simulation
1051 simulation
1060 simulation
1281 simulation
1298 simulation
1363 simulation
1504 simulation
1573 simulation
1578 simulation
1589 simulation
1592 simulation
1600 simulation
1656 simulation
1660 simulation
1666 simulation
1684 simulation
1926 simulation
1928 simulation
1978 simulation
2014 simulation
2039 simulation
2050 simulation
2051 simulation
2081 simulation
2271 simulation
2317 simulation
2339 simulation
2340 simulation
2359 simulation
2383 simulation
2410 simulation
2424 simulation
2443 simulation
2387 single source shortest paths
2394 single source shortest paths
1002 sorting
1245 sorting
1520 sorting
2092 sorting
2408 sorting
1007 stable sorting
1572 string manipulation
1646 string manipulation
1917 string manipulation
2406 string matching
1128 topological sorting
1785 treap
2201 treap
2255 tree manipulation
1089 union of intervals
1797 variation of Dijkstra's shortest path algorithm
2253 variation of Dijkstra's shortest path algorithm
2395 variation of Dijkstra's shortest path algorithm
2254 vector algebra
2354 vector algebra
2412 vector algebra
1130 vertex connectivity
1308 vertex connectivity
2320 vertex connectivity

wolf5x 2009-06-20 22:30 发表评论

pku 2486 Apple Tree 树形DP+背包DP

Wed, 03 Jun 2009 05:09:00 GMT

http://acm.pku.edu.cn/JudgeOnline/problem?id=2486
题目给定一棵有N个节点的无向树，每个节点有个权值，当第一次到达某节点时，可以获得该权值。从节点1出发，至多走K步，每步能走到当前节点的任意邻接点，要求能获得的权值和的最大值。N<=100，K<=200。

对DFS树中某节点，从它开始，可以进入任意子树获得一定权值后返回该点，也可以不返回（这意味着终止于子树里）。
这样可以设：
dp[i][j][0]: 以i为根, 以至多j步访问该子树并返回原地的最大收获
dp[i][j][1]: 以i为根, 以至多j步访问该子树且不需要返回时的最大收获
那么，dp[1][K][1]就是最终结果。
显然这两个值的更新过程可以用深搜DP。

考虑以r为根的DFS子树，则dp[r][j][0..1]的更新，实际上是以步数j为背包容量，以所有子树为物品的背包问题。
于是可以再设：
dps[i][j][0]：前i棵子树，最大步数j，需要返回时的最大收获
dps[i][j][1]：前i棵子树，最大步数j，不需要返回时的最大收获
DFS完一棵子树就做一次背包，状态复杂度O(K*子树数），转移复杂度O(K)
整体复杂度为O(N*K^2)

代码如下：

 1 #include <cstdio>
 2 #include <cstdlib>
 3 #include <cstring>
 4 #include <cmath>
 5 #include <algorithm>
 6 using namespace std;
 7 
 8 struct EDGE{
 9     int v,e;
10 }edg[330];
11 int se, gg[110];
12 bool vis[110];
13 int w[110],dp[110][220][2];
14 int N,K;
15 
16 inline void addedge(int u, int v){
17     edg[se].v = v;
18     edg[se].e = gg[u];
19     gg[u] = se++;
20 }
21     
22 bool input(){
23     int i,j,k;
24     if(scanf("%d %d",&N,&K)==EOF)
25         return false;
26     se = 2;
27     memset(gg,0,sizeof(gg));
28     for(i=1; i<=N; i++)
29         scanf("%d",&w[i]);
30     for(i=1; i<=N-1; i++){
31         scanf("%d %d",&j,&k);
32         addedge(j,k);
33         addedge(k,j);
34     }
35 }
36 
37 void dfs(int r){
38     int i,j,k,u,v,e;
39     int mx0, mx1;
40     vis[r] = true;
41     for(e=gg[r]; e>0; e=edg[e].e){
42         u = edg[e].v;
43         if(!vis[u]){
44             dfs(u);
45             for(k=K; k>=0; k--){
46                 mx0 = mx1 = w[r];
47                 for(j=0; j<=k-1; j++){
48                     if(k>=2 && j<=k-2){
49                         mx0 = max(mx0, dp[r][j][0]+dp[u][k-2-j][0]);
50                         mx1 = max(mx1, dp[r][j][1]+dp[u][k-2-j][0]);
51                     }
52                     if(k>=1 && j<=k-1){
53                         mx1 = max(mx1, dp[r][j][0]+dp[u][k-1-j][1]);
54                     }
55                 }
56                 dp[r][k][0] = max(dp[r][k][0], mx0);
57                 dp[r][k][1] = max(dp[r][k][1], mx1);
58             }
59         }
60     }
61 }
62 
63 void solve(){
64     int i,j,k;
65     for(i=1; i<=N; i++)
66         for(j=0; j<=K; j++)
67             dp[i][j][0] = dp[i][j][1] = w[i];
68     memset(vis,false,sizeof(vis));
69     dfs(1);
70     printf("%d\n", max(dp[1][K][0],dp[1][K][1]) );
71 }
72 
73 int main(){
74     while(input()){
75         solve();
76     }
77     return 0;
78 }

wolf5x 2009-06-03 13:09 发表评论

北大校赛A(grids 3741) Escape

Mon, 18 May 2009 10:33:00 GMT

grids 3741 Escape
http://poj.grids.cn/problem?id=3741
此题我用组合数学过的. 欢迎交流各种方法.

原题意: 从(0,0)开始,初始面向y轴正方向,只能右转或直走,每个格子至多经过1次,到达(x,y),求有多少种走法

转化为: 从(x,y)开始,初始朝向任意,只能左转或直走,!@#%^$#$^^$@%,到达(0,0)的走法数
总的走法数即为初始朝向分别为上下左右的走法数之和.

观察符合要求的路径,其肯定是螺旋形的,也就是各边不相交.
所以可以分别设 (x,y)上方横线数up, 下方横线数down, 左侧竖线数left, 右侧竖线数right
按初始朝向分4种情况,可以找出up,down,left,right之间的数量关系! 可以自己画一下,很容易发现.

以初始朝向左为例,求 S左:
left-1 = up = right = down (令其 = k)
这样对某个k ,走法数即为在4个方位取出对应数量线段的方法数.
设(x,y)到地图4个边界的距离分别为 dl, du, dr, dd
则 Sk = C(left-1, dl-1) * C(up, du) * C(right, dr) * C(down, dd)
其中left项的上下标都减了1,是因为左侧竖线肯定有一条是y轴,所以只选出剩下的left-1条

枚举所有不会越界的 k ,即保证 C(k, n) 中 k<=n, 就求得这个方向方法数之和

最后把4个方向的S加起来即可

注意一些特殊情况:
1. (x,y)在 y 轴上时,直接输出1
2. 初始方向为下的情况,枚举k要从1开始,也就是至少要绕一圈. 因为 !%!@^$#$@#$ :)

ps.
初始朝向上: left-1 = up-1 = right = down
初始朝向右: left-1 = up-1 = right-1 = down
初始朝向下: left = up = right = down

代码:

 1 #include <cstdio>
 2 #include <cstdlib>
 3 #include <cstring>
 4 #include <algorithm>
 5 using namespace std;
 6 
 7 const __int64 MOD = 100000007;
 8 __int64 x,y,X,Y,c[2100][2100];
 9 __int64 ans,tmp;
10 int dk[4][4] = {//lurd
11     1,0,0,0, //left
12     1,1,0,0, //up
13     1,1,1,0, //right
14     1,1,1,1  //down
15 };
16 int N;
17 
18 __int64 func(__int64 n, __int64 k){
19     if(n<k) return 0;
20     if(c[n][k]<0)
21         c[n][k] = (func(n-1, k-1) + func(n-1, k)) % MOD;
22     return c[n][k];
23 }
24 
25 inline int mi4(int x1, int x2, int x3, int x4){
26     return min(min(x1,x2),min(x3,x4));
27 }
28 
29 int main(){
30     int i,j,k,z;
31     int left,right,up,down;
32     memset(c, 0xff, sizeof(c));
33     c[0][0] = 1;
34     for(i=1; i<=2000; i++){
35         c[i][0] = 1;
36         c[i][1] = i;
37         c[i][i] = 1;
38     }
39     scanf("%d",&N);
40     while(N--){
41         scanf("%I64d %I64d %I64d %I64d",&X, &Y, &x, &y);
42         left = x; right = X-x;
43         up = Y-y; down = y;
44         if(x == 0){
45             printf("1\n");
46             continue;
47         }
48         ans = 0;
49         for(i=0; i<4; i++){
50             z = mi4(left-dk[i][0], up-dk[i][1], right-dk[i][2], down-dk[i][3]);
51             for(k=0; k<=z; k++){
52                 tmp = func(left-1, k+dk[i][0]-1) % MOD;
53                 tmp = (tmp * func(up, k+dk[i][1])) % MOD;
54                 tmp = (tmp * func(right, k+dk[i][2])) % MOD;
55                 tmp = (tmp * func(down, k+dk[i][3])) % MOD;
56                 ans = (ans + tmp) % MOD;
57             }
58         }
59         printf("%I64d\n",ans);
60     }
61     return 0;
62 }
63 

wolf5x 2009-05-18 18:33 发表评论

pku 2679 Adventurous Driving (Bellman-Ford, SPFA)

Wed, 06 May 2009 03:17:00 GMT

摘要: 求所谓的 optimal path:对某个顶点,只能沿着它所有出边中weight最小的那些路走;从起点到终点的总weight最小;如果有weight相同的,取总length最短的.可能有负环,自环,平行边. 先将不符合要求的边删掉.接着,关键在于如何判断有效负环,即该负环处在起点到终点的路上.实际上,只用保留原图中从起点能到达,并且能到达终点的顶点.如果用标准bellman-ford,需要2次D... 阅读全文

wolf5x 2009-05-06 11:17 发表评论

hdu 1005 用mod的循环性质

Sat, 25 Apr 2009 03:55:00 GMT

http://acm.hdu.edu.cn/showproblem.php?pid=1005
A number sequence is defined as follows:
f(1) = 1, f(2) = 1, f(n) = (A * f(n - 1) + B * f(n - 2)) mod 7.
Given A, B, and n, you are to calculate the value of f(n).
1 <= A, B <= 1000, 1 <= n <= 100,000,000

解:
f(n) = (A * f(n - 1) + B * f(n - 2)) %7
= (A * f(n - 1) %7 + B * f(n - 2) %7) %7
所以对于给定的A和B,可以先打表,找出数列的循环部分. 鸽巢原理知,状态总数不会超过7*7
注意循环节不一定从f(3)开始...

 1#include <iostream>
 2using namespace std;
 3
 4int a,b,n,x,y,l,h,m[7][7],q[300];
 5int main(){
 6    while(scanf("%d%d%d",&a,&b,&n)!=EOF && (a||b||n)){
 7        memset(m, 0, sizeof(m));
 8        q[1] = q[2] = 1;
 9        x = y = 1; l=3;
10        while(m[x][y]==0){ //该状态还未经历过,则扩展
11            q[l] = (a*x+b*y)%7;
12            m[x][y] = l;
13            y = x;
14            x = q[l++];
15        }
16        //此时,q[1h-1]为前面的非循环部分
17         //q[hl-1]为循环节
18        h = m[x][y]; //循环节的起始位置
19        if(n<h) printf("%d\n",q[n]);
20        else printf("%d\n",q[((n-h)%(l-h))+h]);
21    }
22    return 0;
23}

wolf5x 2009-04-25 11:55 发表评论

bnu 1069 按位贪心,二的幂次

Sat, 25 Apr 2009 03:44:00 GMT

http://acm.cist.bnu.edu.cn/contest/problem_show.php?pid=1069

给一些物品,虚拟币价格v[i]=2^(ki-1),实际价值w[i].现给S个虚拟币.要求把这些虚拟币恰好花完,并且购得物品的实际价值总和最大.

显然,可行的购买方案必能将所购物品分成若干组,其中每组的总价格为2^(pi-1),其中pi为S的二进制表示为1的所有位.

因此可以按位贪心,从S的最低位开始.设当前处理第k位:
1.选取剩余物品价格为2^(k-1)中价值最大的那个,如果没有价格为2^(k-1)的物品,则表示任务无法达成.
2.将其它价格为2^(k-1)的物品,按价值从大到小排序,相邻两个合并成价格为2^k的物品,累积到下一阶段.

这里挖掘出的贪心性质为: 一个数第k位的1,只能由不高于第k位的1合成得到.

wolf5x 2009-04-25 11:44 发表评论

pku 1276 Cash Machine 以2的幂次为基底表示整数

Sat, 11 Apr 2009 05:21:00 GMT

http://acm.pku.edu.cn/JudgeOnline/problem?id=1276
题目大意是:
给定N种面值分别为d[k]的钞票,数量分别为n[k]张.再给一个整数cash.
求,用这些钞票能表示出的不大于cash的最大值是多少.
数据范围N<=1000, n[k]<=1000, cash<=100000

最简单的DP思路是大背包.把每一张钞票看成一件物品,把cash看成背包容量.
这样的复杂度是O(sigma(n[k])*cash),上限是10^11,显然难以应付1000ms的时限.

此处便需利用一个整数的性质来压缩钞票数:
易知,1,2,4,...,2^(k-1)这些数的线性组合,可以表示出任意小于2^k的正整数.
所以如果n[i]=2^k-1,那么实际上钞票k,就可以转化为分别用系数(1,2,4,...,2^k-1)去乘d[k]而得到的钞票各一张.
如果n[i]!=2^k-1,只需取系数1,2,4,..,2^(k-1),n[i]-(2^k-1),其中k是使2^k-1<=n[i]的最大整数.

代码如下:

 1 #include <iostream>
 2 #include <algorithm>
 3 using namespace std;
 4 int dp[100010],mark;
 5 int sn,cash;
 6 struct BILL{
 7     int n,d;
 8 }b[1010];
 9 int ans;
10 
11 void go_dp(){
12     int i,k,upb,r,s;
13     dp[0]=mark;
14     ans=0;
15     for(k=0; k<sn; k++){
16         r=1; //系数:2的幂次
17         while(b[k].n>0){
18             if((r<<1)-1>b[k].n){
19                 r=b[k].n-(r-1);
20                 b[k].n=0;
21             }
22             s=r*b[k].d; //新钞票的面值
23             upb=min(ans+s,cash);
24             for(i=upb; i>=s; i--){
25                 if(dp[i-s]==mark){
26                     dp[i]=mark;
27                     if(ans<i) ans=i;
28                 }
29             }
30             r<<=1;
31             if(ans==cash) return;
32         }
33     }
34 }
35 
36 int main(){
37     int i,j,k;
38     mark=0;
39     while(scanf("%d%d",&cash,&sn)!=EOF){
40         ans=0; mark++;
41         for(i=0;i<sn;i++){
42             scanf("%d%d",&b[i].n,&b[i].d);
43             ans+=b[i].n*b[i].d;
44         }
45         if(ans>cash)
46             go_dp();
47         
48         printf("%d\n",ans);
49     }
50     return 0;
51 }
52 

另,在网上搜得另一种思路,开bool数组记录每个总额是否能达到,开个2维数组记录达到相应总额每种钞票使用数
个人以为,这种方法不能保证总得到最优解.考察如下的例子:
cash=3*4*5=60
钞票(面值*张数):3*19,4*14,5*11
假设55的方案恰好是5*11,56的方案恰好是4*14,57的方案恰好是3*19,那么在考虑60时就找不到解了.实际上60是可以达到的.

wolf5x 2009-04-11 13:21 发表评论

tju 3214 floyd变种

Tue, 31 Mar 2009 06:39:00 GMT

最近做了两道floyd变种的题目,又加深了对floyd原理的理解.

第2题: tju 3214 Find the Path
http://acm.tju.edu.cn/toj/showp3214.html

题目大意是给一个无向图,每个结点有个点权c[p]
对于查询的点对i,j和权k,求在中间节点(不包含端点i,j)权值不大于k的限制下,i,j间最短路径.
由于查询次数多,因此一次查询复杂度需要在O(logn)以内.考虑计算出所有点对在所有限制条件下的最短路,O(1)查询.
限制条件不作用于端点i,j,正好可以用floyd解决.因为floyd正是不断向中间点集中加入点.只要限制一下这些被加入点的条件,就可以解决这题了.
初步归纳,对于查询i,j,k,应该输出将所有c[p]<=k的点加入后的floyd[i,j]
对于限制k,点集的情况是:加了权最小的m个(0<=m<=N),这些点的权都不超过k
因此将点按权值升序排列.dist[k][i][j]表示:前k个点被加入后,i,j间的最短路.

代码如下:

1#include <iostream>
2using namespace std;
3int T,N,M,Q,pc[210];
4int C[210],dist[210][210][210];
5bool mycmp(int a, int b){
6    return (C[a]<C[b]);
7}
8int main(){
9    int i,j,k,p,a,b,c;
10    scanf("%d",&T);
11    while(T--){
12        memset(dist,0xff,sizeof(dist));
13        scanf("%d%d",&N,&M);
14        C[pc[0]=0]=-1;
15        for(i=1;i<=N;i++){
16            scanf("%d",&C[i]);
17            pc[i]=i;
18        }
19        sort(pc,pc+N+1,mycmp);
20        for(i=1; i<=M; i++){
21            scanf("%d%d%d",&a,&b,&c);
22            dist[0][a+1][b+1]=c;
23            dist[0][b+1][a+1]=c;
24        }
25        //floyd
26        for(k=1; k<=N; k++){
27            p=pc[k];
28            for(i=1; i<=N; i++){
29                for(j=1; j<=N; j++){
30                    if(dist[k][i][j]<0)
31                        dist[k][i][j]=dist[k-1][i][j];
32                    else if(dist[k-1][i][j]>=0)
33                        dist[k][i][j]=min(dist[k][i][j],dist[k-1][i][j]);
34
35                    if(i!=j && dist[k-1][i][p]>=0 && dist[k-1][p][j]>=0){
36                        if(dist[k][i][j]<0)
37                            dist[k][i][j]=dist[k-1][i][p]+dist[k-1][p][j];
38                        else
39                            dist[k][i][j]=min(dist[k][i][j], dist[k-1][i][p]+dist[k-1][p][j]);
40                    }
41                    //printf("%d,%d,%d(%d) ",k,i,j,dist[k][i][j]);
42                }
43            }
44        }
45        //query
46        scanf("%d",&Q);
47        while(Q--){
48            scanf("%d%d%d",&a,&b,&c);
49            //顺序查找
50            for(i=0; i<=N && C[pc[i]]<=c; i++);
51            printf("%d\n",dist[i-1][a+1][b+1]);
52        }
53        printf("\n");
54    }
55    return 0;
56}
57

wolf5x 2009-03-31 14:39 发表评论

bupt 1460 floyd变种

Tue, 31 Mar 2009 06:20:00 GMT

最近做了两道floyd变种的题目,又加深了对floyd原理的理解.

第1题: bupt 1460 游览路线
http://acm.cs.bupt.cn/onlinejudge/showproblem.php?problem_id=1460
大意是给定一个无向图,找出一个环,使得环的长度最短,并且这个环上至少有3个顶点.

一种O(mn^2)的做法是枚举每条边,用dijkstra求由原图删去这条边后的新图中u,v间最短路径dist[u,v],该环长度即为map[u,v]+dist[u,v].输出环长度值最小的那个.

仔细分析知道,这题实际上是要求每对点u,v间不包含边的最短路径.想到floyd正是计算所有点对最短路径的.但是这里不能包含边的条件就是变化所在.

floyd的原理是依次往"中间点集"中加入点k,再更新任意点对dist[i,j].
此题中,如果直接枚举map[i,k]+map[k,j]+floyd[i,j](floyd[i,j]为使用经典算法得到的两点间最短路),有可能出现一个点经过两次的情况.比如由边集{(1,2),(1,3),(1,4)}构成的图,依题意是无解,但是用错误的枚举方法却有解.原因是没有排除(1->2),(2->1->3),(3->1)的情况.此时可以看出,以点k为原点枚举i,j时的floyd[i,j]应该是保证不经过k的,也就是枚举操作应该在往"中间点集"中加入k之前!
这样可以得出算法的大致轮廓:在加入点k前更新dist[i,j]
但是问题是,此时的中间点只有1..k-1,那后面的点k+1..n会不会漏处理呢?
本质上,这题求的是环的长度,而不是路径长度.因此,假如存在一个更短的环,它路径上有k之后的点p1,p2,...,pm,设其中最后处理的那个点是pl.那么这个环一定会在向中间点集中加入pl的那次循环里枚举到.
因此不存在漏解问题.

代码如下:

1 #include <iostream>
2 using namespace std;
3 int N,M,ans;
4 //w是原图矩阵,d是floyd最短路矩阵
5 int w[110][110],d[110][110];
6 int main(){
7     int i,j,k,a,b,c;
8     while(scanf("%d%d",&N,&M)!=EOF){
9         for(i=1;i<=N;i++)
10             for(j=1;j<=N;j++)
11                 w[i][j]=d[i][j]=0;
12         for(i=1;i<=M;i++){
13             scanf("%d%d%d",&a,&b,&c);
14             if(!w[a][b]||c<w[a][b]){
15                 w[a][b]=w[b][a]=c;
16                 d[a][b]=d[b][a]=c;
17             }
18         }
19         ans=0x7fffffff;
20         for(k=1;k<=N;k++){
21             //先枚举map[i,k]+map[k,j]+floyd[i,j]
22             for(i=1;i<k;i++)
23                 for(j=i+1;j<k;j++)
24                     if(w[i][k]&&w[k][j]&&d[i][j])
25                         ans=min(ans,d[i][j]+w[i][k]+w[k][j]);
26             //再向中间点集中加入k并更新floyd矩阵
27             for(i=1;i<=N;i++){
28                 if(!d[i][k])continue;
29                 for(j=1;j<=N;j++){
30                     if(!d[k][j]||i==j)continue;
31                     if(!d[i][j]||d[i][j]>d[i][k]+d[k][j])
32                         d[i][j]=d[i][k]+d[k][j];
33                 }
34             }
35         }
36         if(ans<0x7fffffff)
37             printf("%d\n",ans);
38         else
39             puts("No solution.");
40     }
41     return 0;
42 }

wolf5x 2009-03-31 14:20 发表评论

bupt 1032 最长不减序列

Fri, 27 Mar 2009 05:23:00 GMT

/*
    bupt 1032
    nlogn LIS
    注意!
    是最长不减序列(*1),而非最长升序列(*2)
    则当t>=D[len]就直接更新len+1
    而t    将t接在D[j]后得到更长的不减序列,同时更新D[j+1]=t
    这是我WA很多次的地方.对这个算法未理解透彻
    附一组原先错误程序WA的数据:
40
9 7 10 13 18 4 13 37 24 7 30 17 36 20 23 26 35 16 7 25 7 30 39 3 9 11 14 8 29 35 35 17 6 11 25 25 21 17 32 38
答案12
*/
#include <iostream>
using namespace std;
int T,N,m,cnt,r[50010];
int main(){
    int i,j,k;
    scanf("%d",&T);
    while(T--){
        scanf("%d",&N);
        cnt=0; r[0]=-1;
        for(i=1;i<=N;i++){
            scanf("%d",&m);
            if(m>=r[cnt]){ //not '>'
                r[++cnt]=m;
            }
            else{
                int bl=1,bh=cnt,bm;
                k=-1;
                while(bl<=bh){
                    bm=(bl+bh)/2;
                    if(r[bm]>m){ //not '>='
                        bh=bm-1;
                        k=bm;
                    }
                    else bl=bm+1;
                }
                r[k]=m;
            }
        }
        printf("%d\n",cnt);
    }
    return 0;
}

wolf5x 2009-03-27 13:23 发表评论

bupt 1379 Ceil 计算大数的ceil(n/2)

Wed, 25 Mar 2009 14:52:00 GMT

http://acm.cs.bupt.cn/onlinejudge/showproblem.php?problem_id=1379

给一个长度10MB的大数n,要求计算ceil(n/2),内存只有1000K,显然不能开数组,要边读边除
通常的除法只要设个变量记录每位是否整除(mod).此外题目要求不输出前导0,再设个bool值记录(zero)
特殊之处在于向上取整.举个例子:1999/2=1000,显然直接除一位输出一位有问题
关键之处在于增加一个变量记录连续的9的个数(cnt9).如果处理到非9的位,或者输入文件结束,就分情况输出前面最近一位非9数除的结果,然后循环输出9除的结果.因此,还要一个变量记录上一位除得的商(co)

1 /*
2     记录连续9的个数,为了使输入末尾有连续9时向上取整
3     co记录上位除的商
4     mod记录上位除的余数
5     cnt9记录连续的9的个数
6     zero记录前导是否为0
7     当前位不是9时,输出之前的结果,并将当前位+mod*5存入co
8     当前位是9时,cnt9++
9     输入结束时,处理末尾几位
10     注意:
11         输入为0时
12         以9开头时
13         以x9开头时
14
15     几组数据:
16     000319900099 159950050
17     199 100
18     0199 100
19     1998 999
20     99 50
21     0 0
22 */
23 #include <iostream>
24 using namespace std;
25 int main(){
26     bool zero;
27     int mod,cnt9;
28     char co,cn,ct;
29     zero=true; mod=0; co=0; cnt9=0;
30     while(isdigit(cn=getchar())){
31         cn-='0';
32         if(cn!=9){
33             if(!zero||co){
34                 zero=false;
35                 putchar(co+'0');
36             }
37             if(cnt9)zero=false;
38             while(cnt9--){
39                 putchar(4+5*mod+'0');
40                 mod=1;
41             }
42             cnt9=0;
43             co=(cn>>1)+5*mod;
44             mod=cn&1;
45         }
46         else{
47             cnt9++;
48         }
49     }
50     if(!zero||co||mod){
51         zero=false;
52         putchar(co+mod+'0');
53     }
54     mod=1-mod;
55     if(cnt9)zero=false;
56     while(cnt9--){
57         putchar(5*mod+'0');
58         mod=0;
59     }
60     //输入0的情况!
61     if(zero)putchar('0');
62     putchar('\n');
63     return 0;
64 }
65

wolf5x 2009-03-25 22:52 发表评论

pku 2195 Going Home 标准的二分图带权匹配 KM算法

Sun, 15 Feb 2009 14:10:00 GMT

摘要: BFS实现，O(n^3) Code highlighting produced by Actipro CodeHighlighter (freeware)http://www.CodeHighlighter.com/--> 1 #include 2 using namespace... 阅读全文

wolf5x 2009-02-15 22:10 发表评论