C++博客-生无所息-随笔分类-URAL

URAL 1022 Genealogical tree

Chen Jiecao — Tue, 21 Jul 2009 09:14:00 GMT

拓扑排序是最直接的算法.

1 /* 拓扑排序 */
2
3 #include<iostream>
4 #include<vector>
5 using namespace std;
6 const int MAXN=120;
7 vector<int> adj[MAXN];
8
9 int into[MAXN];
10
11 int main()
12 {
13   //freopen("data.in","r",stdin);
14   //freopen("data.out","w",stdout);
15   int n;
16   memset(into,0,sizeof(into));
17   cin >> n;
18   for (int i=1;i<=n;++i)
19     {
20       int x;
21       cin >> x;
22       while (x!=0)
23     {
24       adj[i].push_back(x);
25       ++into[x];
26       cin >> x;
27     }
28     }
29  //for (int i=1;i<=n;++i) cout << into[i] << ' '; cout << endl;
30   bool everp=0;
31   for (int k=0;k<n;++k)
32     {
33       int i=1;
34       for (;i<=n;i++) if (!into[i]) break;
35       (everp) ? cout << ' ' << i : cout << i;
36       everp=1;
37       --into[i];
38       for (int j=0;j<adj[i].size();++j) --into[ adj[i][j] ];
39     }
40   cout << endl;
41   return 0;
42 }
43

Chen Jiecao 2009-07-21 17:14 发表评论

URAL 1021 Sacrament of the sum

Chen Jiecao — Tue, 21 Jul 2009 09:12:00 GMT

水题,由于给出的已经是单调的序列,所以有o(N)的算法

1 #include<iostream>
2 using namespace std;
3 const int MAXN=50005;
4
5
6 int main()
7 {
8   freopen("data.in","r",stdin);
9   freopen("data.out","w",stdout);
10   int c,cc,num[MAXN];
11   cin >> c;
12   for (int i=0;i<c;++i) cin >> num[i];
13   num[c]=31440461;
14   cin >> cc;
15   int p=0;
16   for (int i=0;i<cc;++i)
17     {
18       int x;
19       cin >> x;
20       while (x+num[p]<10000) ++p;
21       if (x+num[p]==10000) { cout << "YES\n"; return 0; }
22     }
23   cout << "NO\n";
24   return 0;
25 }
26

Chen Jiecao 2009-07-21 17:12 发表评论

URAL 1020 Rope

Chen Jiecao — Mon, 20 Jul 2009 08:49:00 GMT

水题,没什么好说的,注意N=1的情况.

1 #include<iostream>
2 #include<math.h>
3 using namespace std;
4 const double PI=3.1415926;
5
6 template <class T>
7 T dis(T x1,T y1,T x2,T y2)
8 {
9   return sqrt( (x1-x2)*(x1-x2) + (y1-y2)*(y1-y2) );
10 }
11 int main()
12 {
13   int n;
14   double r,len=0;
15   //freopen("data.in","r",stdin);
16   //freopen("data.out","w",stdout);
17   cin >> n >> r;
18   double x0,y0,x,y;
19   cin >> x0 >> y0;
20   double px=x0,py=y0;
21 if (n==1) goto L1;
22   for (int i=1;i<n;++i)
23     {
24       cin >> x >> y;
25       len+=dis(px,py,x,y);
26       px=x;
27       py=y;
28     }
29   len+=dis(x,y,x0,y0);
30 L1:  len+= 2*PI*r ;
31   printf("%.2f\n",len);
32   return 0;
33 }
34

Chen Jiecao 2009-07-20 16:49 发表评论

URAL 1019 A line painting

Chen Jiecao — Mon, 20 Jul 2009 07:00:00 GMT

A Line painting

Time Limit: 2.0 second
Memory Limit: 16 MB

The segment of numerical axis from 0 to 10⁹ is painted into white color. After that some parts of this segment are painted into black, then some into white again and so on. In total there have been made N re-paintings (1 ≤ N ≤ 5000). You are to write a program that finds the longest white open interval after this sequence of re-paintings.

Input

The first line of input contains the only number N. Next N lines contain information about re-paintings. Each of these lines has a form:
a_i b_i c_i
where a_i and b_i are integers, c_i is symbol 'b' or 'w', a_i, b_i, c_i are separated by spaces.
This triple of parameters represents repainting of segment from a_i to b_i into color c_i ('w' — white, 'b' — black). You may assume that 0 < a_i < b_i < 10⁹.

Output

Output should contain two numbers x and y (x < y) divided by space(s). These numbers should define the longest white open interval. If there are more than one such an interval output should contain the one with the smallest x.

Sample

input	output
4 1 999999997 b 40 300 w 300 634 w 43 47 b	47 634

这个题目最直接的办法是离散化,离散化了之后就好折腾了,因为操作指令很少,所以我选择离散+朴素染色.
复杂度上界为O(M*M),这里M表示离散化后得到的区间个数.

1 #include<iostream>
2 #include<algorithm>
3 using namespace std;
4 const int MAXN=10005;
5 const int MAXL=1000000000;
6 struct re
7 {
8   int a,b;
9   char c;
10 }op[MAXN];
11
12 int n,p=0,que[MAXN];
13 bool color[MAXN<<1];
14
15 /* 二分查找 */
16 int find(int num)
17 {
18   int l=0,r=p+1,mid;
19   while (r-l>1)
20     {
21       mid=(l+r) >> 1;
22       (que[mid]<=num)? l=mid : r=mid;
23       if (que[l]==num) return l;
24     }
25   return l;
26 }
27
28 void disp(re& op)
29 {
30   /* 区间由1开始数,而不是由0开始 */
31   op.a=find(op.a)+1;
32   op.b=find(op.b);
33 }
34
35 void mark(int l,int r,char c)
36 {
37   for (int i=l;i<=r;++i) color[i]=(c=='b');
38 }
39
40 int main()
41 {
42  // freopen("data.in","r",stdin);
43  // freopen("data.out","w",stdout);
44   cin >> n;
45   for (int i=0;i<n;++i)
46     {
47       cin >> op[i].a >> op[i].b >> op[i].c;
48       que[++p]=op[i].a;
49       que[++p]=op[i].b;
50     }
51   que[++p]=MAXL;
52   /* 删除重复出现的数字 */
53   int rp=0;
54   for (int i=1;i<=p;++i)
55     if (que[rp]!=que[i]) que[++rp]=que[i];
56   p=rp;
57   /* 排序,便于定位和离散化 */
58   sort(que,que+p+1);
59   que[p+1]=MAXL+1;
60   /* 对操作进行离散处理 */
61   for (int i=0;i<n;++i) disp(op[i]);
62   /* 处理操作序列 */
63   memset(color,0,sizeof(color));
64   for (int i=0;i<n;++i) mark(op[i].a,op[i].b,op[i].c);
65   int t=1,a,b,mlen=0;
66   for (int i=2;i<=p+1;++i)
67     if (color[i]!=color[t] || i>p)
68       {
69     if ((!color[t]) && (que[i-1]-que[t-1]>mlen)) { a=que[t-1];b=que[i-1];mlen=que[i-1]-que[t-1];}
70     t=i;
71       }
72   cout << a << ' ' << b << endl;
73   //system("pause");
74   return 0;
75 }
76

个别目标远大的同学可能并不仅仅是想解决这个题目,这时候建议你使用离散化+线段树,复杂度会大大地降低

Chen Jiecao 2009-07-20 15:00 发表评论

URAL 1018 A Binary Apple Tree

Chen Jiecao — Sun, 19 Jul 2009 15:02:00 GMT

A Binary Apple Tree

Time Limit: 1.0 second
Memory Limit: 16 MB

Let's imagine how apple tree looks in binary computer world. You're right, it looks just like a binary tree, i.e. any biparous branch splits up to exactly two new branches. We will enumerate by natural numbers the root of binary apple tree, points of branching and the ends of twigs. This way we may distinguish different branches by their ending points. We will assume that root of tree always is numbered by 1 and all numbers used for enumerating are numbered in range from 1 to N, where N is the total number of all enumerated points. For instance in the picture below N is equal to 5. Here is an example of an enumerated tree with four branches:

As you may know it's not convenient to pick an apples from a tree when there are too much of branches. That's why some of them should be removed from a tree. But you are interested in removing branches in the way of minimal loss of apples. So your are given amounts of apples on a branches and amount of branches that should be preserved. Your task is to determine how many apples can remain on a tree after removing of excessive branches.

Input

First line of input contains two numbers: N and Q (1 ≤ Q ≤ N; 1 < N ≤ 100). N denotes the number of enumerated points in a tree. Q denotes amount of branches that should be preserved. Next N−1 lines contains descriptions of branches. Each description consists of a three integer numbers divided by spaces. The first two of them define branch by it's ending points. The third number defines the number of apples on this branch. You may assume that no branch contains more than 30000 apples.

Output

Output should contain the only number — amount of apples that can be preserved. And don't forget to preserve tree's root ;-)

Sample

input	output
5 2 1 3 1 1 4 10 2 3 20 3 5 20	21

简析:
      这是一个简单的树形动态规划问题,大概可以拿来当这类题目的入门训练题.虽然这是URAL上的第一个树形DP,但是我奇怪的是它的通过率并不很高.
      对于原题目的图形,用数组value[a][b]表示a,b点间苹果的个数,用nd[p].L,nd[p].R分别表示节点p的左右儿子.通过build_tree(1)获得数组nd[],从而获得整棵树的信息.
接着,用ans[p][i]表示以节点p为祖宗的子树,保留的枝条不超过i条时所能保留的最多的苹果,状态转移有一下几种情况.
在除去多余枝条的后的图中,
1. p只与一个儿子相连:
    ans[p][i]=max(ans[left_son][i-1]+value[left_son][p],ans[right_son][i-1]+value[right_son][p]);
2. p与两个儿子相连:
    for (int j=0;j<=i-2;++j)
      ans[p][i]=max(ans[p][i],ans[left_son][j]+ans[right_son][i-j-2]+d);
    这里,d=value[left_son][p]+value[right_son][p];

算法在o(N*Q*Q)级别

1 #include<iostream>
2 using namespace std;
3 const int MAXN=102;
4 int n,q,value[MAXN][MAXN],ans[MAXN][MAXN];
5 struct node
6 {
7   int l,r;
8 }nd[MAXN];
9
10 void build_tree(int p)
11 {
12   int flg=0;
13   for (int i=1;i<=n;++i)
14     if (value[p][i] && (!nd[i].l))
15       {
16     flg=1;
17     if (nd[p].l==0) nd[p].l=i;
18     else
19       {nd[p].r=i; break;}
20       }
21   if (!flg) return;
22   if (nd[p].l) build_tree(nd[p].l);
23   if (nd[p].r) build_tree(nd[p].r);
24 }
25
26 void calc(int p)
27 {
28   if (!nd[p].l) return;
29   int l=nd[p].l,r=nd[p].r;
30   calc(l);
31   calc(r);
32   ans[p][1]=max(value[l][p],value[r][p]);
33
34   int d=value[l][p]+value[r][p];
35   for (int i=2;i<=q;++i)
36   {
37     ans[p][i]=max(ans[l][i-1]+value[l][p],ans[r][i-1]+value[r][p]);
38     for (int j=0;j<=i-2;++j)
39       ans[p][i]=max(ans[p][i],ans[l][j]+ans[r][i-j-2]+d);
40   }
41 }
42
43
44 int main()
45 {
46   //freopen("data.in","r",stdin);
47   //freopen("data.out","w",stdout);
48   cin >> n >> q;
49   memset(value,0,sizeof(value));
50   for (int i=1;i<n;++i)
51     {
52       int a,b,c;
53       cin >> a >> b >> c;
54       value[a][b]=c;
55       value[b][a]=c;
56     }
57   memset(nd,0,sizeof(nd));
58   build_tree(1);
59   calc(1);
60   cout << ans[1][q] << endl;
61   return 0;
62 }
63

Chen Jiecao 2009-07-19 23:02 发表评论