C++博客-Better man-文章分类-ACM

zoj 1015(弦图)

SHFACM — Wed, 04 Feb 2009 08:21:00 GMT

至今不明白原理
无向图中，如果任意边数大于3的环，至少存在一条边连接环中不相邻的某两
个点，则称此图为弦图(Chordal Graph)，所以说这里的算法就是
第一步：给节点编号
设已编号的节点集合为A，未编号的节点集合

1 /*
2 无向图中，如果任意边数大于3的环，至少存在一条边连接环中不相邻的某两
3 个点，则称此图为弦图(Chordal Graph)
4 */
5 #include <iostream>
6 using namespace std;
7 int n,m;
8 bool map[1001][1001];
9 bool used[1001];
10 int seta[1001];
11 void number()
12 {
13       memset(used,0,sizeof(used));
14       used[1]=1;
15       seta[n]=1;
16       for(int num=n-1;num>=1;--num)
17       {
18             int Max=0;
19             int p=0;
20             for(int i=1;i<=n;++i)
21                   if(!used[i])
22                   {
23                         int sum=1;
24                         for(int k=n;k>=num;--k)
25                               if(map[i][seta[k]])
26                                     sum++;
27                         if(sum>Max)
28                         {
29                               Max=sum;
30                               p=i;
31                         }
32                   }
33             seta[num]=p;
34             used[p]=1;
35       }
36 }
37 bool check()
38 {
39       int setc[1001];
40       for(int i=1;i<n;++i)
41       {
42             int x=seta[i];
43             int k=0;
44             for(int j=i+1;j<=n;++j)
45             {
46                   int y=seta[j];
47                   if(map[x][y])
48                         setc[k++]=y;
49             }
50             if(k>1)
51             {
52                   for(int j=1;j<k;j++)
53                         if(!map[setc[0]][setc[j]])return 0;
54             }
55       }
56       return true;
57 }
58 int main()
59 {
60       int a,b;
61       while(scanf("%d%d",&n,&m)&&n)
62       {
63             memset(map,0,sizeof(map));
64             for(int i=1;i<=m;++i)
65             {
66                   scanf("%d%d",&a,&b);
67                   map[b][a]=map[a][b]=1;
68             }
69             //编号
70             number();
71             if(check())printf("Perfect\n\n");
72             else printf("Imperfect\n\n");
73       }
74       return 0;
75 }

为B
开始时A为空，B包含所有节点。
for num=n-1 downto 0 do
{
在B中找节点x，使与x相邻的在A集合中的节点数最多，将x编号为num，
并从B移入A
}
第二步：检查
for num=0 to n-1 do
{
对编号为num的节点x，设所有编号大于num且与x相邻的节点集合为C，
在集合C中找出编号最小的节点y，如果集合C中存在不等于y的节点z，
且y与z间没有边，则此图不是弦图，退出。
}
检查完了，则此图是弦图。

SHFACM 2009-02-04 16:21 发表评论

usaco telecow

SHFACM — Tue, 03 Feb 2009 11:37:00 GMT

求最小点集，可以通过最小割集转化，把点拆开变成边，这样就转化成了求最小割集；
注意把点拆开时边的转变：把每个点i拆成两个点i1,i2，这两个点之间建立一条边权为1的有向弧。对于原图中边(i,j)，建立(i2,j1)和(j2,i1)两条边权为∞的有向弧。对于每个点i（非c1,c2），把边(i1,i2)去掉，求最大流，记为nowflow，记当前找到的最小割集中元素的数量为cnt。如果 netflow-cnt=nowflow+1，那么点i一定是最小割集中的割点，记录下来。否则将边(i1,i2)重新加上。直到 cnt=netflow，当前找的集合就是最小割集。

1 #include<iostream>
2 using namespace std;
3 int n,m,s,t;
4 int graph[101*2][101*2];//残留网络
5 int cp[101*2][202];
6 int Edmonds_Karp(int s,int t)
7 {
8       int flow=0;
9       int cp[101*2];
10       int pre[101*2];
11       int que[100000];
12       while(true)
13       {
14             cp[s]=INT_MAX;
15             memset(pre,0,sizeof(pre));
16             int head=0,tail=1;que[0]=s;
17             while(head!=tail)
18             {
19                   int i=que[head++];
20                   for(int j=1;j<=2*n;j++)    //节点从0算起
21                         if(j != i && !pre[j] && graph[i][j]>0)
22                         {
23                               cp[j]=min(cp[i],graph[i][j]);
24                               que[tail++]=j;
25                               pre[j]=i;
26                         }
27             }
28             if(pre[t]==0)break;
29             int i=t;
30             while(i!=s)
31             {
32                   int j=pre[i];
33                   graph[j][i]-=cp[t];
34                   graph[i][j]+=cp[t];
35                   i=j;
36             }
37             flow+=cp[t];
38       }
39       return flow;
40 }
41 int main()
42 {
43       int a,b;
44       freopen("telecow.in","r",stdin);
45       freopen("telecow.out","w",stdout);
46       scanf("%d%d%d%d",&n,&m,&s,&t);
47       for(int i=1;i<=n;++i)
48             graph[2*i-1][2*i]=1;
49       for(int i=1;i<=m;++i)
50       {
51             scanf("%d%d",&a,&b);
52             graph[2*b][2*a-1]=graph[2*a][2*b-1]=INT_MAX;
53       }
54       for(int i=1;i<=n;++i)
55             graph[2*t][2*i-1]=graph[2*i][s*2-1]=0;
56       memcpy(cp,graph,sizeof(graph));
57       int Max;
58       printf("%d\n",Max=Edmonds_Karp(2*s,2*t-1));
59       bool flag=1;
60      for(int i=1;i<=n;++i)
61       {
62             if(i==s||i==t)continue;
63             memcpy(graph,cp,sizeof(cp));
64             graph[2*i-1][2*i]=0;
65             int tmp=Edmonds_Karp(2*s,2*t-1);
66             cp[2*i-1][2*i]=1;
67             if(tmp+1==Max)
68             {
69                   if(flag)
70                   {
71                         printf("%d",i);
72                         flag=0;
73                   }
74                   else printf(" %d",i);
75                   cp[2*i-1][2*i]=0;
76                   Max=tmp;
77             }
78       }
79      printf("\n");
80       return 0;
81 }
82

SHFACM 2009-02-03 19:37 发表评论

usaco rectbarn

SHFACM — Tue, 03 Feb 2009 06:28:00 GMT

极大化思想的应用！
用l，r分别记录了之前的状态！
下一次查找的时候只需要o(1)的时间，最坏情况下是o(n),不过由于坏点很稀疏，最坏情况很少发生！
所以程序非常快！

   Test 1: TEST OK [0.000 secs, 11544 KB]
   Test 2: TEST OK [0.011 secs, 11544 KB]
   Test 3: TEST OK [0.011 secs, 11544 KB]
   Test 4: TEST OK [0.011 secs, 11544 KB]
   Test 5: TEST OK [0.011 secs, 11544 KB]
   Test 6: TEST OK [0.022 secs, 11540 KB]
   Test 7: TEST OK [0.054 secs, 11544 KB]
   Test 8: TEST OK [0.194 secs, 11544 KB]
   Test 9: TEST OK [0.302 secs, 11540 KB]
   Test 10: TEST OK [0.281 secs, 11544 KB]

1 动态规划
2 小炫耀一下
3 程序运行的非常快么！
4 /*
5 ID: hongfei5
6 PROG: rectbarn
7 LANG: C++
8 */
9 #include<iostream>
10 using namespace std;
11 bool map[3001][3001];
12 int h[3001],l[3001],r[3001];
13 int n,m,p;
14 int main()
15 {
16       freopen("rectbarn.in","r",stdin);
17       freopen("rectbarn.out","w",stdout);
18       scanf("%d%d%d",&n,&m,&p);
19       int a,b;
20       for(int i=0;i<p;++i)
21       {
22             scanf("%d%d",&a,&b);
23             map[a][b]=1;//1表示是坏点
24       }
25       h[0]=0;
26       int Max=0;
27       //[i,j]为(i,h[i,j])这条线段向左边扩展的最长距离，r[i,j]为(i,h[i,j])向右边扩展的最长距离
28       for(int i=1;i<=n;++i)
29       {
30             l[i]=0;
31             r[i]=m+1;
32             for(int j=1;j<=m;++j)
33                   if(map[i][j])
34                   {
35                         r[i]=j;
36                         break;
37                   }
38       }
39       for(int j=1;j<=m;++j)
40       {
41             int len_l=INT_MAX;
42             int len_r=INT_MAX;
43             for(int i=1;i<=n;++i)
44             {
45                   if(map[i][j])
46                   {
47                         l[i]=j;
48                         h[i]=0;
49                         r[i]=m+1;
50                         len_l=len_r=INT_MAX;
51                         for(int k=j+1;k<=m;++k)
52                               if(map[i][k])
53                               {
54                                     r[i]=k;
55                                     break;
56                               }
57                   }
58                   else
59                   {
60                         h[i]=h[i-1]+1;
61                         len_l=min(len_l,j-l[i]);
62                         len_r=min(len_r,r[i]-j);
63                         int s=(len_l+len_r-1)*h[i];
64                         if(s>Max)Max=s;
65                   }
66             }
67       }
68       printf("%d\n",Max);
69       return 0;
70 }

SHFACM 2009-02-03 14:28 发表评论

usaco milk4

SHFACM — Mon, 02 Feb 2009 10:28:00 GMT

1 dfsid+dp速度并不是很快！
2 #include<iostream>
3 #include<algorithm>
4 using namespace std;
5 int q,n;
6 bool dp[20001];
7 int num[101];
8 int ans[101];
9 int pre[101];
10 void dfsid(int Max,int dep)
11 {
12       if(dep==Max+1)
13       {
14             memset(dp,0,sizeof(dp));
15             dp[0]=1;
16             for(int i=1;i<=Max;++i)
17                   for(int j=1;j<=q;++j)
18                         if(j>=ans[i])dp[j]=dp[j]|dp[j-ans[i]];
19             if(dp[q])
20             {
21                   printf("%d",Max);
22                   sort(ans+1,ans+Max);
23                   for(int i=1;i<=Max;++i)
24                         printf(" %d",ans[i]);
25                   printf("\n");
26                   exit(0);
27             }
28             return ;
29       }
30       for(int i=pre[dep-1]+1;i<=n-Max+dep;++i)
31       {
32             ans[dep]=num[i];
33             pre[dep]=i;
34             dfsid(Max,dep+1);
35       }
36 }
37 int main()
38 {
39       freopen("milk4.in","r",stdin);
40       freopen("milk4.out","w",stdout);
41       scanf("%d%d",&q,&n);
42       for(int i=1;i<=n;++i)
43             scanf("%d",&num[i]);
44       for(int i=1;i<=n;++i)
45       {
46             pre[0]=0;
47             dfsid(i,1);
48       }
49       return 0;
50 }

SHFACM 2009-02-02 18:28 发表评论

usaco theme

SHFACM — Mon, 02 Feb 2009 04:05:00 GMT

优化：
（1）如果以i开头的长度为l的序列没有匹配序列，那么比l更长的序列一定不会有解，可以直接跳过。
1 (1)纯模拟-一次过
2 #include<iostream>
3 using namespace std;
4 int n;
5 int s[5001];
6 int main()
7 {
8       freopen("theme.in","r",stdin);
9       freopen("theme.out","w",stdout);
10       int i,j;
11       scanf("%d",&n);
12       for (i=0;i<n;++i)
13             scanf("%d",&s[i]);
14       int Max=1;
15       for(int i=0;i+2*Max-1<n;++i)
16       {
17             for(int j=i+Max-1;j+Max-1<n;++j)
18             {
19                   int k=1;
20                   while(1)
21                   {
22                         if(i+Max>=j)break;
23                         if(s[i+k]-s[j+k]==s[i]-s[j])
24                         {
25                               k++;
26                               if(k>Max)Max=k;
27                         }
28                         else break;
29                   }
30             }
31       }
32       if(Max>=5)printf("%d\n",Max);
33       else printf("0\n");
34       return 0;
35 }

1 (2)动态规划
2 //空间不够
3 #include<iostream>
4 using namespace std;
5 int n;
6 char s[5001];
7 char dp[5001][5001];
8 int main()
9 {
10       freopen("theme.in","r",stdin);
11       freopen("theme.out","w",stdout);
12       int i,j;
13       scanf("%d",&n);
14       for (i=0;i<n;++i)
15             scanf("%d",&s[i]);
16       for(i=0;i<n;++i)
17             for(j=0;j<n;++j)
18                   dp[i][j]=1;
19       int Max=1;
20       for(i=n-2;i>=0;--i)
21             for(j=n-2;j>=0;--j)
22             {
23                   if(i==j)continue;
24                   if(i+dp[i+1][j+1]>=j)continue;
25                   if(s[j+1]-s[j]==s[i+1]-s[i])
26                         dp[i][j]=dp[i+1][j+1]+1;
27                   if(dp[i][j]>Max)Max=dp[i][j];
28             }
29       if(Max>=5)printf("%d\n",Max);
30       else printf("0\n");
31       return 0;
32 }

SHFACM 2009-02-02 12:05 发表评论

usaco job

SHFACM — Sun, 01 Feb 2009 14:15:00 GMT

第一问比较简单，用贪心做就可以了。用now[i]记录A中机器工作的时间，初始时为0。每次使当前最大工作时间最小，即找到一个j使得 now[j]+t[j]最小，其中t是A中机器j完成一次操作的时间。让机器j完成这次操作，更新now[i]，同时记录第i件工作被完成的时间 fin[i]。

贪心的证明比较容易，这里就不说了（反证）。

第二问初看似乎无从下手，我们不妨换个角度，把A和B独立开，换句话说，等A工作全部结束后B工作才开始，那么B和A是一样的，用贪心求出这时每件工作被完成的时间sta[i]。

fin和sta中的数是单调递增的，我们设想一下，把fin中最大的和sta中最小的数对应，记做某件工作完成的时间（因为所有工作都是一样的），fin中次大的和sta中次大的数对应，记做另一件工作完成的时间，依此类推。去所有的完成时间最大的就是问题二的解。

单调性

这个图可能更形象一些：

0 && image.height>0){if(image.width>=700){this.width=700;this.height=image.height*700/image.width;}}" src="http://photo.hexun.com/p/2006/0131/9642/b_15D7B52B56948D55.jpg" alt="查看更多精彩图片" border="0">

SHFACM 2009-02-01 22:15 发表评论

usaco window

SHFACM — Sat, 31 Jan 2009 03:26:00 GMT

  1 #include<iostream>
  2 using namespace std;
  3 struct Rect
  4 {
  5       int x1,y1,x2,y2;//分别为左上角和右下角(左上角为最小的横纵坐标)
  6       int level;//标识符
  7       int s;//面积为0表示不存在
  8 }rect[100],que[50000],now;
  9 int Max,Min;
10 int front,rail;
11 int cal(char a)
12 {
13       if(a<='9'&&a>='0')return a-'0';
14       if(a<='Z'&&a>='A')return a-'A'+10;
15       if(a<='z'&&a>='a')return a-'a'+36;
16 }
17 void t(char a)
18 {
19       rect[cal(a)].level=++Max;
20 }
21 void b(char a)
22 {
23       rect[cal(a)].level=--Min;
24 }
25 void d(char a)
26 {
27       rect[cal(a)].s=0;
28 }
29 void w(char a,int x1,int y1,int x2,int y2)
30 {
31       t(a);
32       rect[cal(a)].x1=x1;
33       rect[cal(a)].x2=x2;
34       rect[cal(a)].y1=y1;
35       rect[cal(a)].y2=y2;
36       rect[cal(a)].s=(y2-y1)*(x2-x1);
37 }
38 bool cross(int x1,int x2,int x3,int x4)//两条线段 x1-x2,x3-x4
39 {
40       if(x2<=x3||x4<=x1)return false;
41       return true;
42 }
43 void add(int x1,int y1,int x2,int y2,int level)
44 {
45       que[rail].x1=x1;
46       que[rail].x2=x2;
47       que[rail].y1=y1;
48       que[rail].y2=y2;
49       que[rail].level=level;
50       rail++;
51 }
52 void cut(int x1,int y1,int x2,int y2,int dir,int k,int level)
53 {
54       int k1,k2;
55       switch(dir)
56       {
57             //先从x方向切
58       case 1:
59             {
60                   k1=max(x1,rect[k].x1);
61                   k2=min(x2,rect[k].x2);
62                   if(x1<k1)add(x1,y1,k1,y2,level);
63                   if(k2<x2)add(k2,y1,x2,y2,level);
64                   cut(k1,y1,k2,y2,dir+1,k,level);
65                   break;
66             }
67             //再从y方向切
68       case 2:
69             {
70                   k1=max(y1,rect[k].y1);
71                   k2=min(y2,rect[k].y2);
72                   if(y1<k1)add(x1,y1,x2,k1,level);
73                   if(k2<y2)add(x1,k2,x2,y2,level);
74             }
75       }
76 }
77 void s(char a)
78 {
79       front=0;
80       rail=1;
81       que[0]=rect[cal(a)];
82       for(int k=0;k<62;++k)
83       {
84             if(rect[k].s==0)continue;
85             if(rect[k].level<=rect[cal(a)].level)continue;
86             int j=rail,i=front;
87             while(i!=j)
88             {
89                   now=que[front++];
90                   if(cross(now.x1,now.x2,rect[k].x1,rect[k].x2)&&cross(now.y1,now.y2,rect[k].y1,rect[k].y2))
91                         cut(now.x1,now.y1,now.x2,now.y2,1,k,now.level);
92                   else add(now.x1,now.y1,now.x2,now.y2,now.level);
93                   i++;
94             }
95       }
96       int sum=0;
97       for(int s=front;s<rail;++s)
98             sum+=(que[s].y2-que[s].y1)*(que[s].x2-que[s].x1);
99       printf("%.3lf\n",(double)sum/(double)rect[cal(a)].s*100.0);
100 }
101 int main()
102 {
103       freopen("window.in","r",stdin);
104       freopen("window.out","w",stdout);
105       char tmp;
106       char a;
107       int x1,y1,x2,y2;
108       Max=Min=0;
109       while(1)
110       {
111             if(scanf("%c",&tmp)==-1)break;
112             if(tmp=='w')
113             {
114                   scanf("(%c,%d,%d,%d,%d)",&a,&x1,&y1,&x2,&y2);
115                   if(x1>x2)swap(x1,x2);
116                   if(y1>y2)swap(y1,y2);
117                   w(a,x1,y1,x2,y2);
118             }
119             else if(tmp=='t')
120             {
121                   scanf("(%c)",&a);
122                   t(a);
123             }
124             else if(tmp=='b')
125             {
126                   scanf("(%c)",&a);
127                   b(a);
128             }
129             else if(tmp=='d')
130             {
131                   scanf("(%c)",&a);
132                   d(a);
133             }
134             else if(tmp=='s')
135             {
136                   scanf("(%c)",&a);
137                   s(a);
138             }
139             getchar();
140       }
141       return 0;
142 }

SHFACM 2009-01-31 11:26 发表评论