C++博客-littlekid-随笔分类-Problem Solving

再谈Toplogical sort（pku 1094）

littlekid@R2 — Thu, 15 May 2008 04:13:00 GMT

    很久没有在blog上写解题报告了。。。前一阵子都在看书，看算导，看中大的书。。。差点被认为是没有在做ACM了。。。怪我自己。
    在中大的书上看到一段写的不错的toplogical sort的代码，用它来过了一直没过的1094，后来看到kid的代码，发现他写麻烦了。其实判环不用那么麻烦，在拓扑排序里就可以判环了。值得注意的是，每次删点时都要判断是否存在两个或两个以上的入度为0的点，因为这样是不能determin的。如果没有这一步就会wa，比如如下数据：
4 5
ACBAB若没有那么做的话，会在输出
Sorted sequence determined after 4 relations：ACBD.
但是实际上在第四步还没有确定。

代码比kid的短，呵呵。
                                        ——Simbaforrest

代码如下：

#include<iostream>
#include<cstring>
using namespace std;
int v,e;
int deg[26];
int sortAns[26],anstop;
bool adj[26][26];

int TopSort()
{
  int ret=1;
  bool sure=true;
  //init
  memset(deg,0,sizeof(deg));
  //count degree
  for(int i=0; i<v; i++)
  {
    for(int j=0; j<v; j++)
    {
      if(adj[i][j]==true)
        ++deg[j];
    }
  }
  //make stack of 0 degree vertex
  int top=-1;
  int cnt=0;
  for(int i=0; i<v; i++)
  {
    if(deg[i]==0)
    {
      ++cnt;
      deg[i]=top;
      top=i;
    }
  }
  if(cnt==0)
  {
    sure=true;
    return ret=-1;//cycle exist
  }
  if(cnt>1)
  {
    sure=false;
    ret=0;//unsure
  }//go on to see if cycle exist

  //sort
  anstop=-1;
  for(int i=0; i<v; i++)
  {
    if(top==-1)
    {
      //cycle exist
      sure=true;
      return ret = -1;
    }
    else
    {
      //find j as the 0 degree vertex
      int j = top;
      top = deg[top];
      sortAns[++anstop]=j;//record the ans

      //delete the vertex j
      cnt=0;
      for(int ni=0; ni<v; ni++)
      {
        if(adj[j][ni]==true)
        {
          --deg[ni];
          //a new 0 degree vertex
          if(deg[ni]==0)
          {
            ++cnt;
            deg[ni]=top;
            top = ni;
          }
        }
      }
      if(cnt>1)
      {
        sure=false;
        ret=0;//unsure
      }//go on to see if cycle exist
    }
  }
  if(sure==false)
    return ret=0;
  return ret;
}

int main()
{
  while(cin>>v>>e,!(v==0&&e==0))
  {
    //init
    memset(adj,0,sizeof(adj));
    bool sure=false;

    //read and solve
    for(int i=0; i<e; i++)
    {
      char left,op,right;
      cin>>left>>op>>right;
      adj[left-'A'][right-'A']=1;

      if(sure)
        continue;

      int ret=TopSort();
      if(ret!=0)
      {
        sure=true;
        if(ret==1)
        {
          cout<<"Sorted sequence determined after "<<i+1<<" relations: ";
          for(int j=0; j<=anstop; j++)
            cout<<(char)(sortAns[j]+'A');
          cout<<"."<<endl;
        }
        else if(ret==-1)
        {
          cout<<"Inconsistency found after "<<i+1<<" relations."<<endl;
        }
      }
    }
    if(sure==false)
    {
      cout<<"Sorted sequence cannot be determined."<<endl;
    }
  }
  return 0;
}

littlekid@R2 2008-05-15 12:13 发表评论

【图论】【Dijstra】最短奇偶路径

littlekid@R2 — Tue, 01 Apr 2008 06:47:00 GMT

摘要: WHU08CC_PRE之path解题报告
我的Dijstra＋优先队列标准程序阅读全文

littlekid@R2 2008-04-01 14:47 发表评论

【数论】扩展欧几里德的一个妙用

littlekid@R2 — Fri, 14 Mar 2008 08:46:00 GMT

摘要: 对于 a/b%m = ans, 求 ans。阅读全文

littlekid@R2 2008-03-14 16:46 发表评论

WOJ入门宝典（一）

littlekid@R2 — Fri, 14 Mar 2008 05:57:00 GMT

WOJ入门宝典（一）

——WOJ题目总结 by littlekid

我在WOJ（http://acm.whu.edu.cn/oak ）上做过的水题最多了，在这里给出一份题目总结，用于新手入门。

说明：下面的难度是以我的水平划分的，如果你的想法不一样也不奇怪。

有些题目都给了算法，没给的基本上就是那种实在不值得说（说出来题目就只剩下编程了）。另外，很多题目是我刚进集训队时AC的，所以也不清楚具体算法了，下面很多可能有错，欢迎提出意见。

时间有限，这里是第一版的题目；

A+B Problem 60.15% (1488/2474)

不说了

1002 Genesis 13.28% (200/1506)

简单，字符串处理，数单词，推荐

1003 Birth of Noah 15.4% (77/500)

我是画图水过去的，不建议做

1004 Noah's 16.8% (82/488)

单位转换，很繁，不建议

1005 Holding Animals 23.84% (133/558)

简单题，贪心

1006 Language of Animals 20.72% (98/473)

中等，链表＋DFS，很值得做

1007 Feeding Animals(I) 35.21% (287/815)

简单，贪心，推荐

1008 Feeding Animals(II) 36.11% (91/252)

中等，贪心也可以过，正规解法是二分匹配

1009 The Legend of Valiant Emigration 69.89% (72/103)

中等，图论（最短路），推荐

1010 Alternate Sum 32.66% (290/888)

中等，排序＋一个结论（如果知道结论就简单了）

1011 Finding Teammates 29.14% (51/175)

1012 Think And Count 15.9% (69/434)

1013 Bracelet 29.04% (258/888)

简单，字符串排序，推荐

1014 Doraemon’s Flashlight 30.50% (137/449)

几何题，如果像我一样数学没学好不推荐

1015 N-Queen Puzzle(Special Judged) 20.36% (79/388)

稍难，回溯＋转换判断，很推荐，想好再做

1016 Cherry Blossom 29.09% (167/574)

中等，二分，推荐

1017 Billiard Ball 41.55% (86/207)

1018 King Kong 23.96% (92/384)

1019 Curriculum Schedule 26.97% (75/278)

1020 Adjacent Difference 27.32% (212/776)

简单，排序，推荐

1021 Bob’s Problem (Special Judged) 21.5% (135/628)

1022 Competition of Programming 26.20% (126/481)

中等，贪心，推荐

1023 Division 26.91% (67/249)

简单，DP，推荐

1024 Exploration 29.2% (66/226)

中等，利用树的性质＋求最短路

1025 Finding Nemo 8.55% (20/234)

1026 Game On Checkerboard 37.82% (163/431)

简单，DP，推荐

1027 Heating the Ants 13.19% (12/91)

1028 Injured Bishop Problem 40.57% (170/419)

简单

1029 Ascend 27.74% (177/638)

简单，模拟

1030 Sphere Route 21.17% (29/137)

1031 Chocolates 17.81% (39/219)

1032 Find the Max NORM 43.41% (56/129)

1033 Natural Span 39.53% (34/86)

1034 Cut the Apple 24.92% (149/598)

公式题，不推荐

1035 BG 58.37% (324/555)

简单

1036 Cards 25.11% (119/474)

简单博弈，推荐

1037 Circular_Road 33.5% (135/403)

简单，推荐

1038 Help! 30.86% (79/256)

中等，最短路

1039 Key 30.08% (117/389)

中等，可以水过，标准做法是线段树

1040 MagicBuilding 41.67% (140/336)

简单

1041 MagicForest 16.66% (55/330)

中等，DFS或BFS

1042 Polygon 32.32% (32/99)

1043 Magicstar 11.83% (71/600)

难，我是水过去的，标准做法是RMQ

1044 Polygon Revolution 46.67% (7/15)

1045 Flymouse’s Poor English 34.13% (128/375)

简单

1046 Crazy Game 46.73% (157/336)

中等，逆序数

1047 LCS Problem 21.54% (173/803)

中等，经典DP，推荐

1048 Relationship 25.16% (37/147)

1049 Words 34.26% (37/108)

简单，DP，推荐

1050 Network 43.21% (70/162)

简单，最小生成树，推荐

Bus Route Problem 50.0% (9/18)

1053 Lian lian 23.33% (14/60)

1054 DNA 14.61% (13/89)

1055 The Hardest Problem Ever 39.72% (143/360)

简单

1056 Sonia's Travel 14.29% (24/168)

1057 Problem 2046 32.43% (12/37)

1058 Exchange 24.18% (111/459)

简单

1059 Tollbooth 18.09% (17/94)

1060 Magic Number 14.64% (111/758)

简单，推荐

1061 Simple Cut Problem 23.33% (35/150)

1062 Linear World 20.05% (78/389)

中等，公式题，不过题意有错

1063 Fine-X-Path 21.58% (30/139)

1064 What Is Left 23.01% (191/830)

简单，基数排序，推荐

1065 2D Path Problem 48.24% (96/199)

简单

1066 Athena 19.05% (24/126)

1067 Weight 14.14% (46/325)

1068 Chess 30.76% (20/65)

1069 Poor Knuthocean 30.64% (125/408)

1070

1071 Joseph problem 24.25% (105/433)

难，线段树

1072 Order 15.36% (57/371)

中等，贪心

1073 Coins 29.43% (83/282)

简单，公式，推荐做完后了解整个理论

1074 ABC 33.54% (162/483)

中等，推荐

1075 Ball 33.14% (57/172)

1076 Center 29.03% (54/186)

1077 Dragonflywww 39.53% (85/215)

中等，DP，推荐

1078 Emotional Rate 22.06% (30/136)

1079 Fractions 14.93% (20/134)

1080 Game 43.29% (171/395)

简单

1081 Hunter 34.69% (127/366)

难，二分匹配

1082 魔教的传信站 23.05% (56/243)

1083 机关大师的设计 29.50% (72/244)

难，拓扑排序，推荐

1084 连续技 30.43% (28/92)

1085 回家的路 44.25% (50/113)

1086 棋盘游戏(SHD) 33.95% (55/162)

1087 数星星 32.06% (109/340)

中等，推荐

1088 从1开始的N个连续自然数的M次方之和 18.9% (55/291)

1089 进军路线 21.57% (77/357)

难，Dijstra或BFS，推荐

1090 Snail 11.11% (30/270)

1091 WOJ's computer 13.33% (4/30)

1092 Pure numbers 33.45% (98/293)

中等

1093 Monkeys 15.29% (13/85)

1094 Special Graph 33.33% (24/72)

1095 Chess 19.42% (20/103)

1096 Race 47.92% (23/48)

1097 Circle 40.63% (52/128)

难，组合数学题，我直接模拟数出来的（太恐怖了）

1098 Dongfangxu&zap 26.22% (70/267)

中等，字符串统计

1099 flirly 20.48% (43/210)

难，

1100 Forest 33.82% (117/346)

简单，直接模拟，推荐

littlekid@R2 2008-03-14 13:57 发表评论

“过桥问题”的解答

littlekid@R2 — Tue, 11 Mar 2008 03:05:00 GMT

http://www.oursci.org/magazine/200204/020411-01.htm

littlekid@R2 2008-03-11 11:05 发表评论

【树形DP】POJ1947 Rebuilding Roads 解题报告

littlekid@R2 — Sat, 01 Mar 2008 06:16:00 GMT

我对树形DP早有耳闻，不过没有做过相应的题目。最近看集合DP不怎么懂，所以换看树形DP，昨天看到一个题目AC了结果发现跟树形DP的思想不太像，这道题目就完全是基础的树形DP题了，纪念一下，呵呵。

题目来源：USACO 2002 February

题目提交方式：POJ1947
http://acm.pku.edu.cn/JudgeOnline/problem?id=1947

题目描述：
   对于一棵树，问删除一些边使得它的一棵子树正好有p个节点，问最少要删除多少边？
输入：
    N（1<=N<=150)，P(1<=P<=N),接下来是N－1条边的描述（父亲节点在前）。
输出：
    ANS(要删除的最小边数）

解题思路：
    建树比较简单，然后就是设计状态转移方程：
    对于一个节点i：用函数f[i][j]表示以它为根节点能得到j个节点的子树需要删除的最小边数。
    状态转移方程：f[i][j+k] = min(f[i][k]+f[c][j]), c为i的儿子节点。
    最后结果为根f[root][p]和f[i][p]+1(1<=i<=n)中的最小值。
我的代码：

  1 /*********************************************************************
  2 Author: littlekid
  3 Created Time: 2008-3-1 11:38:58
  4 Problem Source: POJ1947
  5 Description:
  6 ********************************************************************/
  7 # include <iostream>
  8 using namespace std;
  9
10 # define N 155
11
12 # define TEST
13
14 const int LARGE_NUMBER = 11111;
15
16 typedef struct _node {
17     _node *next;
18     int id;
19 };
20
21 _node vect[ N ];
22 int n, p, root, ans, f[ N ][ N ];
23
24 void initialize(int n)
25 {
26     for (int i = 1; i <= n; i ++)
27     {
28         vect[i].id = 0;
29         vect[i].next = NULL;
30     }
31 }
32
33 void insert(int v, int u)
34 {
35     _node *p;
36     p = new _node;
37     p->id = u;
38     p->next = vect[v].next;
39     vect[v].next = p;
40     vect[v].id ++;
41 }
42
43 void del(_node *p)
44 {
45     if (p == NULL) return ;
46     del(p->next);
47     delete p;
48 }
49
50 void clear(int n)
51 {
52     for (int i = 1; i <= n; i ++)
53     {
54         del(vect[i].next);
55         vect[i].next = NULL;
56     }
57 }
58
59
60 void init()
61 {
62     int s, t;
63     int flag[n+1];
64     memset(flag, false, sizeof(flag));
65     for (int i = 1; i < n; i ++)
66     {
67         scanf("%d %d", &s, &t);
68         insert(s, t);
69         flag[t] = true;
70     }
71     t = 1;
72     while (flag[t]) t ++;
73     root = t;
74 }
75
76 void output()
77 {
78     printf("%d\n", ans);
79 }
80
81 void DFS(int now)
82 {
83     _node *q = vect[now].next;
84     int tmp;
85     for (int i = 0; i <= p; i ++) f[now][i] = LARGE_NUMBER;
86     f[now][1] = vect[now].id;
87     q = vect[now].next;
88     while (q != NULL)
89     {
90         DFS(q->id);
91         for (int j = p-1; j >= 0; j --)
92         {
93             if (f[now][j] < LARGE_NUMBER)
94             {
95                 for (int k = 1; k < p; k ++)
96                 {
97                     if (f[q->id][k] < LARGE_NUMBER)
98                     {
99                         tmp = f[now][j] + f[q->id][k] -1;
100                         if (tmp < f[now][j+k])
101                         {
102                             f[now][j+k] = tmp;
103                         }
104                     }
105                 }
106             }
107         }
108         q = q->next;;
109     }
110 }
111
112 void dp()
113 {
114     DFS(root);
115
116     #ifdef TEST
117     for (int i = 1; i <= n; i ++)
118     {
119         for (int j = 1; j <= p; j ++)
120         {
121             cout << f[i][j] << " ";
122         }
123         cout << endl;
124     }
125     #endif
126
127     ans = f[root][p];
128     for (int i = 1; i <= n; i++)
129     {
130         if (f[i][p] < ans) ans = f[i][p]+1;
131     }
132 }
133
134 int main()
135 {
136     while (scanf("%d %d", &n, &p) != EOF)
137     {
138         initialize(n);
139         init();
140         dp();
141         output();
142         clear(n);
143     }
144     return 0;
145 }
146
147

littlekid@R2 2008-03-01 14:16 发表评论

【树形DP？】POJ3140解题报告

littlekid@R2 — Fri, 29 Feb 2008 06:09:00 GMT

今天切了一道被推荐为树形DP的题目，想了一会就想出方法了，不过调了不少时间。感觉这个题目只是一个普通的树的题目，不过如果这也算树形DP的话，就是我的第一道（值得纪念了）

题目模型描述：
有N个节点，每个节点有一个权值，这N个节点通过M条边连解，任意两个点之间有且只有一条路径——就是树了！(1 ≤ N ≤ 100000, 1 ≤ M ≤ 1000000),将其分为两棵树，使得这两棵树的权值相差最小，求这个最小值。

解题过程：
我开始一直以为这个题目很难——毕竟是树形DP，后面推出这个题目可以通过DFS来做，然后写了，交上去得到TLE，然后我怀疑方法不对，不过我删去了最后的删掉邻接链表的操作后得到WA，这样我继续调试，看了DISCUSS发现要用Int64,这样就AC了，但是效率不够……不过先发在这里，下午再去找人问高效的算法……

这个题目注意的地方（对于我的算法）：

注意数据大小不能为int，这样会wa

建树时得到的邻接链表在用完后不要一个一个去delete，这样会TLE

对于N＝1的情况，可以认为还有一组0个

  1 /*********************************************************************
  2 Author: littlekid
  3 Created Time: 2008-2-29 11:56:06
  4 Problem Source: POJ3140
  5 Description:
  6
  7 ********************************************************************/
  8
  9 # include <iostream>
10 using namespace std;
11
12 # define N 100010
13
14 typedef struct _node {
15     _node *next;
16     int id;
17 };
18
19 _node vect[ N ];
20 __int64 num[ N ], f[ N ], ans, tot;
21 int n, m;
22 bool flag[ N ];
23
24 void initialize(int n)
25 {
26     for (int i = 1; i <= n; i ++)
27     {
28         vect[i].next = NULL;
29     }
30 }
31
32 void insert(int v, int u)
33 {
34     _node *p;
35     p = new _node;
36     p->id = u;
37     p->next = vect[v].next;
38     vect[v].next = p;
39     p = new _node;
40     p->id = v;
41     p->next = vect[u].next;
42     vect[u].next = p;
43 }
44 /*
45 void del(_node *p)
46 {
47     if (p == NULL) return ;
48     del(p->next);
49     delete p;
50 }
51
52 void clear(int n)
53 {
54     for (int i = 1; i <= n; i ++)
55     {
56         del(vect[i].next);
57         vect[i].next = NULL;
58     }
59 }
60 */
61
62 void init()
63 {
64     tot = 0;
65     for (int i = 1; i <= n; i ++)
66     {
67         scanf("%I64d", &num[i]);
68         tot += num[i];
69     }
70     ans = tot;
71
72     memset(flag, false, sizeof(flag));
73     int s, t;
74     for (int i = 1; i <= m; i ++)
75     {
76         scanf("%d %d", &s, &t);
77         insert(s, t);
78     }
79 }
80
81 void output(int ca)
82 {
83     printf("Case %d: %I64d\n", ca, ans);
84 }
85
86 __int64 DFS(int now)
87 {
88     if (ans < 2) return tot;
89     f[ now ] = num[now];
90     _node *p = vect[now].next;
91     flag[now] = true;
92     while (p != NULL)
93     {
94         if (!flag[p->id]) f[now] += DFS(p->id);
95         p = p->next;
96     }
97     __int64 tmp = abs(tot - 2*f[now]);
98     if (tmp < ans) ans = tmp;
99     return f[ now ];
100 }
101
102 int main()
103 {
104     int ca = 0;
105     while (true)
106     {
107         scanf("%d %d", &n, &m);
108         if (n == 0 && m == 0) break; ca ++;
109         initialize(n);
110         init();
111         DFS(1);
112         output(ca);
113     //    clear(n);
114     }
115     return 0;
116 }
117
118

littlekid@R2 2008-02-29 14:09 发表评论

【DP】PKU1191棋盘分割问题解题报告

littlekid@R2 — Wed, 27 Feb 2008 12:04:00 GMT

摘要: 经典问题“棋盘分割”解题报告阅读全文

littlekid@R2 2008-02-27 20:04 发表评论

【DP】“佳佳的筷子”的解法

littlekid@R2 — Sat, 16 Feb 2008 12:32:00 GMT

题目来源：《算法艺术与信息学竞赛》Page145

题目1.5.12

题目提交方式：uva10271

汗，今天发现我的代码在uva上不能ac，那天比赛数据弱，被我骗过去了～～

题目描述：
   n个数中选k＋8组共（k＋8）×3个数，每组数三个，每组数中较小的两个数Ai，Bi，其代表的值为（Ai－Bi)^2,另所有组的值的和最小。

解题思路：
    (来自OIBH的思路）首先，我们直观的猜测：任意一副筷子中A和B一定是长度相邻的两只筷子。证明如下：对于某副筷子(A1,B1,C1)和另一副筷子(A2,B2,C2)，如果A1<=A2<=B1<=B2，那么交换一下筷子重新组合成(A1,A2,C1)和(B1,B2,C2)质量和会更优。对于某副筷子(A,B,C)和闲置的筷子D，如果A<=D<=B，那么交换一下重新组合成(A,D,C)质量和也会更优。
这样，我们得到了一个线性结构，只需要从左往右或从后往左递推。在本题中，由于第3根筷子比另2根长，所以我们从长筷子往短筷子递推。在递推之前，首先将N只筷子从小到大排序，Li是第i只筷子的长度。
用d[i,j]表示用i..n的单只筷子组成j副筷子的最小质量值之和，则当且仅当n-i+1>=3j的时候状态是合法的。请读者自己写出状态转移方程。
    这个题目比较难，我是看了上面的思路写的，状态转移方程为:
                     f[i][j] = MIN(        f[i-1][j],     f[i+2][j-1] + (a[i+1]-a[i]) * (a[i+1]-a[i])     )//对应与上面思路，
由于数据比较大，实现时用到滚动数组。

题目代码：

1 /*********************************************************************
2 Author: littlekid
3 Created Time: 2008-2-16 13:35:08
4 Problem Source:
5 Description:
6 ********************************************************************/
7 # include <iostream>
8 using namespace std;
9
10 # define N 5005
11
12 const int maxint = 0xfffffff;
13
14 int k, n;
15 int a[ N ];
16 int f[2][N] = { 0 };
17 int ans;
18
19 void init()
20 {
21     scanf("%d %d", &k, &n);
22     for (int i = 0; i < n; i ++)
23     {
24         scanf("%d", &a[i]);
25     }
26     k+=8;
27 }
28
29 int cmp(const void *a, const void *b)
30 {
31     return (*(int *)a-*(int *)b);
32 }
33
34 int MIN(int a, int b)
35 {
36     return a > b ? b : a;
37 }
38
39 void dp()
40 {
41     qsort(a, n, sizeof(a[0]), cmp);
42     //cout << a[0] << endl; ////
43     for (int i = n; i > 0; i --) a[i] = a[i-1];//
44
45     int now = 0, pre = 1;
46
47     for (int j = 1; j <= k; ++j)
48     {
49         if (now == 1)
50         {
51             now = 0, pre = 1;
52         }
53         else
54         {
55             now = 1, pre = 0;
56         }
57         for (int i = j * 2; i <= n; ++i)
58         {
59             if (i > j * 2)
60                 f[now][i] = f[now][i - 1];
61             else
62                 f[now][i] = maxint;
63             if ((n - i) > (k - j) * 3)
64                 f[now][i] = MIN(f[now][i], f[pre][i - 2] + (a[i] - a[i - 1]) * (a[i] - a[i - 1]));
65         }
66     }
67     ans = f[now][n];
68 }
69
70 void output()
71 {
72     printf("%d\n", ans);
73 }
74
75 int main()
76 {
77     int T;    scanf("%d", &T);
78     while (T --)
79     {
80         init();
81         dp();
82         output();
83     }
84     return 0;
85 }
86
87

littlekid@R2 2008-02-16 20:32 发表评论

【几何】昨天我水过去的A题

littlekid@R2 — Wed, 23 Jan 2008 02:03:00 GMT

摘要: 这个题目是老题了，是Northeastern Europe 1996的题目，也就是POJ1444。题目地址：http://acm.pku.edu.cn/JudgeOnline/problem?id=1444 这个解法是错的！！！！比赛时数据菜，水过去了～～～具体解法看Felicia的：http://www.cppblog.com/Felicia/archive/2008/01/23/4... 阅读全文

littlekid@R2 2008-01-23 10:03 发表评论

昨天的D题解题报告

littlekid@R2 — Tue, 22 Jan 2008 06:54:00 GMT

【题目描述】

Problem D - 负权数

Description

当我们写一个十进制正书时，其值可以用各位的数码乘以10 的幂来表示。例如：

123 = 1×102 + 2×101 + 3×100

一般来说，对于R 进制数N，其绝对值可以用各位的数码乘以R 的幂：

N = an×Rn+ an-1×Rn-1 + ... + a0×R0

来表示。这里的R 可以是正书也可以是负数。当R 是负数时，我们称之为负权数。不论R是正数还是负数，我们都采用{0, 1, ... , |R|-1}这R 个数码来表示R 进制数各个位。如果|R|>10,我们还将使用大写字母表示数码。例如，对16 进制数来说，A 表示10（十进制），

B 表示11（十进制），……，F 表示15（十进制）。

使用负权数的一个好处就是在表示负数时，我们不需要用到负号“-”。举例来说，10

进制数-15 用-2 进制数来表示就是110001 :

-15 = 1×(-2)5 + 1×(-2)4 + 0×(-2)3 + 0×(-2)2 + 0×(-2)1 + 1×(-2)0

请设计一个程序读入10 进制数和负数R，输出这个10 进制数的R 进制的形式。

输入数据有多组，以一行“0 0”结束。

Sample Input

30000 -2

-20000 -2

28800 -16

-25000 -16

Sample Output

11011010101110000

1111011000100000

19180

7FB8

【解题思路】

G题与这个题目很相像。

对于一个正数，我们可以先转换为R进制数，再将R进制数转化为－R进制数。知道这种办法，后面就好办了：对于奇数位（从后面数），－R与R进制代表的值是一样的，对于偶数位，可以用高位减当前位表示（如：(-R)^3 * a = (-R)^4 – R^3 * (R-a)）。

再观察负数，可以发现要转换的是奇数位。

具体实现的时候就是先将一个数表示为R进制，然后在对所有的偶数位进行变换，并且注意进位的处理。对于负数，先变成他的相反数，然后对所有的奇数位进行变换。我在实现时直接用tag标记要转换的数，分别用0、1分别表示正数、负数，然后利用数的奇偶进行转换。

【题目代码】

1 /*
2 author:littlekid
3 created time: 2008-1-21
4 description:
5 */
6 # include <iostream>
7 using namespace std;
8
9 int main()
10 {
11     int n, r;
12     int tmp;
13     int a[ 102 ];
14     int k, tag, i;
15     while (true)
16     {
17         scanf("%d %d", &n, &r);
18         if (n == 0 && r == 0) break;
19         if (n == 0) // 0 is special
20         {
21             printf("0\n");
22             continue;
23         }
24         r *= -1;
25         //label the number: a negative or positive number?
26         tag = 1;
27         if (n < 0)
28         {
29             tag = 0;
30             n *= -1;
31         }
32         //translate a decimal number into R-representation number
33         k = 0;
34         memset(a, 0, sizeof(a));
35         while ( n != 0 )
36         {
37             tmp = n % r;
38             a[k++] = tmp;
39             n /= r;
40         }
41         //translate a R-representation number into a -R-representation number
42         i=0;
43         while (i<k || a[i])
44         {
45             if (a[i] >= r)
46             {
47                 a[i] %= r;
48                 a[i+1] ++;
49             }
50
51             if (i%2==tag && a[i])
52             {
53                 a[i] = r-a[i];
54                 a[i+1] ++;
55             }
56             i ++;
57         }
58         //output the answer
59         for (i = i-1; i >= 0; i --)
60         {
61             if (a[i] > 9) printf( "%c", 'A'+a[i]-10);
62             else printf("%d", a[i]);
63         }
64         printf("\n");
65     }
66     return 0;
67 }

littlekid@R2 2008-01-22 14:54 发表评论

下午比赛G题的解题报告

littlekid@R2 — Sun, 20 Jan 2008 11:58:00 GMT

下午比赛做得有点挫。被安排写G题的解题报告，这里顺便贴上来。
——littlekid

题目描述：

【Problem G - 数制转换】

Description
   有一种数制的基数是三，权值可以取-1,0,1，并且分别用符号-.0.1 表示。这种数值的
101 便表示十进制的10，即1×32 + 0×31 + 1×30 = 10，又如这种数制的-0 表示十进制
的-3，即-1×31 + 0×30 = -3。标称要求把给定的有符号证书转换为新数制的数，该数的
前面不能有多余的0，入10 的新数制表示是101，则不要输出乘0101。
输入格式
   数据第一行的数字T 表示输入数据有T 组，接下来的T 行每行有一个整数N(32 位整型
可表示范围内)，整数内不会有其他分隔符。
输出格式
    对输入的每一个数字输出一行，该行是输入行整数的新数制表示。
Sample Input
2
10
-3
Sample Output
101
-0

【题目分析】
    对于每一位，他有一个权值，为这一位乘以3^(i-1)。本题关键点就在于要从后面的位开
始取。如果能想到这里题目就搞定了——实现起来比较简单，还有一点就是负数问题，很快
就能想到每位取反。

【解题思路】
   这个题目解法很简单：首先是正数的情况，对N进行取余，如果得1则这一位为1，为0自然
为0，如果取模得2，则进行转换，当前位取－1。对于负数，转化为相反数处理，然后每位取
反，相反数得相反数就是这个数本身。

【样例程序】

1 /*********************************************************************
2 Author: littlekid
3 Created Time: 2008-1-20 15:28:47
4 Problem Source:
5 Description:
6 ********************************************************************/
7 # include<stdio.h>
8
9 int main()
10 {
11     int t; scanf("%d", &t);
12     int tmp, k, cur, n;
13     int a[20], tag;
14
15     while (t --)
16     {
17         scanf("%d", &n);
18         tmp = n;
19         k = 0;
20         if (n == 0) ////这里开始未考虑到，WA了一次 !!!!!
21         {
22             printf("0\n");
23             continue;
24         }
25
26         tag = 1;
27         if (n < 0) //标记负数
28         {
29             n *= -1;
30             tag = -1;
31         }
32         //主要过程：对n不断除3并求余数
33         while ( n != 0 )
34         {
35             tmp = n%3;
36             if (tmp == 2)
37             {
38                 tmp = -1;
39                 n += 2;
40             }
41             else
42             {
43                 n -= tmp;
44             }
45             a[k] = tmp*tag;
46             n /= 3;
47                k ++;
48         }
49         //输出结果
50         for (int i = k-1; i >= 0; i --)
51         {
52             switch(a[i])
53             {
54                 case 0:printf("0");
55                     break;
56                 case -1:printf("-");
57                     break;
58                 case 1:printf("1");
59                     break;
60                 default:printf("ERROR\n");
61             }
62         }
63         printf("\n");
64     }
65     return 0;
66 }
67

littlekid@R2 2008-01-20 19:58 发表评论

[ZZ]转载的pku题目分类（比较全的一个版本）

littlekid@R2 — Fri, 18 Jan 2008 11:14:00 GMT

说明：递推算动归，离散化算数据结构，并查集算数据结构，博弈算动归，麻烦题一般都是不错的综合题，最短路算图论，数据的有序化算排序

麻烦题：
1697, 1712, 1713, 1720, 1729, 1765, 1772, 1858, 1872, 1960, 1963, 2050, 2122, 2162, 2219, 2237,

简单题目：
1000, 1003, 1004, 1005, 1007, 1046, 1207, 1226, 1401, 1504, 1552, 1607, 1657, 1658, 1674, 1799, 1862, 1906, 1922, 1929, 1931, 1969, 1976, 2000, 2005, 2017, 2027, 2070, 2101, 2105, 2109, 2116, 2136, 2160, 2190, 2232, 2234, 2275, 2301, 2350, 2363, 2389, 2393, 2413, 2419,
推荐：
1063, 1064, 1131, 1140, 1715, 2163,

杂题：
1014, 1218, 1316, 1455, 1517, 1547, 1580, 1604, 1663, 1678, 1749, 1804, 2013, 2014, 2056, 2059, 2100, 2188, 2189, 2218, 2229, 2249, 2290, 2302, 2304, 2309, 2313, 2316, 2323, 2326, 2368, 2369, 2371, 2402, 2405, 2407,
推荐：
1146, 1147, 1148, 1171, 1389, 1433, 1468, 1519, 1631, 1646, 1672, 1681, 1700, 1701, 1705, 1728, 1735, 1736, 1752, 1754, 1755, 1769, 1781, 1787, 1796, 1797, 1833, 1844, 1882, 1933, 1941, 1978, 2128, 2166, 2328, 2383, 2420,

高精度：
1001, 1220, 1405, 1503,

排序：
1002, 1318, 1877, 1928, 1971, 1974, 1990, 2001, 2002, 2092, 2379, 2388, 2418,
推荐：
1423, 1694, 1723, 1727, 1763, 1788, 1828, 1838, 1840, 2201, 2376, 2377, 2380,

搜索
容易：
1128, 1166, 1176, 1231, 1256, 1270, 1321, 1543, 1606, 1664, 1731, 1742, 1745, 1847, 1915, 1950, 2038, 2157, 2182, 2183, 2381, 2386, 2426,
不易：
1024, 1054, 1117, 1167, 1708, 1746, 1775, 1878, 1903, 1966, 2046, 2197, 2349,
推荐：
1011, 1190, 1191, 1416, 1579, 1632, 1639, 1659, 1680, 1683, 1691, 1709, 1714, 1753, 1771, 1826, 1855, 1856, 1890, 1924, 1935, 1948, 1979, 1980, 2170, 2288, 2331, 2339, 2340,

数据结构
容易：
1182, 1656, 2021, 2023, 2051, 2153, 2227, 2236, 2247, 2352, 2395,
不易：
1145, 1177, 1195, 1227, 1661, 1834,
推荐：
1330, 1338, 1451, 1470, 1634, 1689, 1693, 1703, 1724, 1988, 2004, 2010, 2119, 2274,

动态规划
容易：
1018, 1050, 1083, 1088, 1125, 1143, 1157, 1163, 1178, 1179, 1189, 1208, 1276, 1322, 1414, 1456, 1458, 1609, 1644, 1664, 1690, 1699, 1740, 1742, 1887, 1926, 1936, 1952, 1953, 1958, 1959, 1962, 1975, 1989, 2018, 2029, 2033, 2063, 2081, 2082, 2181, 2184, 2192, 2231, 2279, 2329, 2336, 2346, 2353, 2355, 2356, 2385, 2392, 2424,
不易：
1019, 1037, 1080, 1112, 1141, 1170, 1192, 1239, 1655, 1695, 1707, 1733, 1737, 1837, 1850, 1920, 1934, 1937, 1964, 2039, 2138, 2151, 2161, 2178,
推荐：
1015, 1635, 1636, 1671, 1682, 1692, 1704, 1717, 1722, 1726, 1732, 1770, 1821, 1853, 1949, 2019, 2127, 2176, 2228, 2287, 2342, 2374, 2378, 2384, 2411,

字符串：
1488, 1598, 1686, 1706, 1747, 1748, 1750, 1760, 1782, 1790, 1866, 1888, 1896, 1951, 2003, 2121, 2141, 2145, 2159, 2337, 2359, 2372, 2406, 2408,

贪心：
1042, 1065, 1230, 1323, 1477, 1716, 1784,

图论
容易：
1161, 1164, 1258, 1175, 1308, 1364, 1776, 1789, 1861, 1939, 1940, 1943, 2075, 2139, 2387, 2394, 2421,
不易：
1041, 1062, 1158, 1172, 1201, 1275, 1718, 1734, 1751, 1904, 1932, 2173, 2175, 2296,
网络流：
1087, 1273, 1698, 1815, 2195,
匹配：
1274, 1422, 1469, 1719, 2060, 2239,
Euler：
1237, 1637, 1394, 2230,
推荐：
2049, 2186,

计算几何
容易：
1319, 1654, 1673, 1675, 1836, 2074, 2137, 2318,
不易：
1685, 1687, 1696, 1873, 1901, 2172, 2333,
凸包：
1113, 1228, 1794, 2007, 2187,

模拟
容易：
1006, 1008, 1013, 1016, 1017, 1169, 1298, 1326, 1350, 1363, 1676, 1786, 1791, 1835, 1970, 2317, 2325, 2390,
不易：
1012, 1082, 1099, 1114, 1642, 1677, 1684, 1886,

数学
容易：
1061, 1091, 1142, 1289, 1305, 1306, 1320, 1565, 1665, 1666, 1730, 1894, 1914, 2006, 2042, 2142, 2158, 2174, 2262, 2305, 2321, 2348,
不易：
1067, 1183, 1430, 1759, 1868, 1942, 2167, 2171, 2327,
推荐：
1423, 1450, 1640, 1702, 1710, 1721, 1761, 1830, 1930, 2140,

littlekid@R2 2008-01-18 19:14 发表评论

【DP】POJ2353解题报告

littlekid@R2 — Tue, 15 Jan 2008 03:10:00 GMT

题目描述：
        有一栋楼有N（1<=N<=100）层，每层房间有M个房间（1<=M<=500）。每间房间有一个访问开销。从一个房间可以到其周边（上一层同一号，同一层左右两间）。现在要从一楼开始一直访问到顶楼，问怎样走可以获得最小的访问开销？

解题思路：
      双向DP。从一楼到顶楼依次计算从底楼到某一间房子的最小开销。
      技巧点：对于某一层，先计算从下一层或左边向右走的最小开销，再尝试从右边走到左边，看是不是开销可以变小，是则更新。

程序代码：

  1 /*********************************************************************
  2 Author: littlekid
  3 Created Time: 2008-1-15 9:31:18
  4 Problem Source:
  5 Description:
  6     中间WA了两次，查了很久，
  7     最后发现题目描述的是最多M层，每层最多N间房，原来弄反了！是个不小的教训
  8 ********************************************************************/
  9
10 # include <iostream>
11 using namespace std;
12
13 # define MAX 2000000005
14 # define N 555
15 # define M 111
16
17 int n,m;
18 long fee[ M ][ N ], f[ M ][ N ];;
19 int road[ M ][ N ];
20
21 void init()
22 {
23     scanf( "%d %d", &n, &m );
24     for ( int i = 1; i <= n; i ++ )
25     {
26         for ( int j = 1; j <= m; j ++ )
27         {
28             scanf( "%d", &fee[ i ][ j ] );
29         }
30     }
31 }
32
33 void output()
34 {
35     int min = MAX, s = 1;
36     for ( int i = 1; i <= m; i ++ )
37     {
38         if ( f[ n ][ i ] < min )
39         {
40             min = f[ n ][ i ];
41             s = i;
42         }
43     }
44     int step[ n*m+1 ];
45     step[0] = s; s=0;
46     int floor = n;
47     while ( floor > 1 )
48     {
49           s ++;
50           step[ s ] = road[ floor ][ step[s-1] ];
51           if ( step[ s ] == step[ s-1 ] )  floor --;
52     }
53
54     for ( int i = s; i >= 0; i -- )
55     {
56         printf( "%d\n", step[ i ] );
57     }
58 }
59
60 void dp()
61 {
62     int tmp;
63     for ( int i = 1; i <= m; i ++ )
64     {
65         road[1][ i ] = i;
66         f[1][ i ] = fee[1][ i ];
67     }
68     for ( int floor = 2; floor <= n; floor ++ )
69     {
70         f[ floor ][1] = f[ floor-1 ][ 1 ] + fee[ floor ][ 1 ];
71         road[ floor ][1] = 1;
72
73         for ( int i = 2; i <= m; i ++ )
74         {
75             f[ floor ][ i ] = fee[ floor ][ i ];
76             if ( f[ floor ][ i-1 ] < f[ floor-1 ][ i ] )
77             {
78                 f[ floor ][ i ] += f[ floor ][ i-1 ];
79                 road[ floor ][ i ] = i-1;
80             }
81             else
82             {
83                 f[ floor ][ i ] += f[ floor-1 ][ i ];
84                 road[ floor ][ i ] = i;
85             }
86         }
87
88         for ( int i = m-1; i > 0; i -- )
89         {
90             tmp = f[ floor ][ i+1 ] + fee[ floor ][ i ];
91             if ( tmp < f[ floor ][ i ] )
92             {
93                 f[ floor ][ i ] = tmp;
94                 road[ floor ][ i ] = i+1;
95             }
96         }
97     }
98 }
99
100 int main()
101 {
102     int n,m;
103     init();
104     dp();
105     output();
106     return 0;
107 }
108
109

littlekid@R2 2008-01-15 11:10 发表评论

【Toplogical Sort】【解题回顾】我写poj1094的过程

littlekid@R2 — Fri, 11 Jan 2008 07:27:00 GMT

摘要: 好久没写程序练手了，今天本来准备拿POJ1025开刀的，但是1025这个模拟题目太繁杂了，换一个，写POJ1094，结果郁闷地写了三个多小时——代码水平有待提升呀。下面是我写这个题目的详细过程，跟大家分享下：题目地址：http://acm.pku.edu.cn/JudgeOnline/p... 阅读全文

littlekid@R2 2008-01-11 15:27 发表评论

【DP】POJ1141 Brackets Sequence解题报告

littlekid@R2 — Wed, 09 Jan 2008 13:40:00 GMT

//o(∩_∩)o...哈哈，我回来做题了……

POJ1141是一个经典DP题，是一个“历史遗留”问题了。
一个简单版本
WOJ1077：Dragonflywww
http://acm.whu.edu.cn/oak/problem/problem.jsp?problem_id=1077

题目描述：
     给出一个由(、)、[、]组成的字符串，添加最少的括号使得所有的括号匹配，输出最后得到的字符串。

解题思路：
      用DP求最少需要括号数：以p从1到n（字符串长度），记录下从i到i+p需要添加的最少括号数f[i][j],同时记录下中间需要添加括号的位置pos[i][j]——为-1表示不需要添加。这种方法我原来就知道，所以过了WOJ1077。
     最麻烦的就是添加括号构造字符串了，这里借鉴别人的方法用递归实现，程序里写得很清楚了，要利用pos[i][j]。

  1 /*************************************************************************
  2 Author: littlekid
  3 Created Time: 1/9/2008 7:04:26 PM
  4 Problem Source: POJ1141
  5 Description:
  6 ************************************************************************/
  7 # include <stdio.h>
  8 # include <string.h>
  9 # include <stdlib.h>
10
11 # define N 222
12
13 const int maxint=0x7FFFFFFF;
14 typedef long long int64;
15 const int64 maxint64 = 0x7FFFFFFFFFFFFFFFLL;
16
17 int f[ N ][ N ], pos[ N ][ N ];
18 char s[ N ];
19 int n;
20
21 inline int MIN( int a, int b )
22 {
23     return a > b ? b : a;
24 }
25
26 void init()
27 {
28     scanf( "%s", &s );
29 }
30
31 void output()
32 {
33     printf( "%d\n", f[ 1 ][ n ] );
34     for ( int i = 1; i <= n; i ++ )
35     {
36         for ( int j = 1; j <= n; j ++ )
37         {
38             printf( "%c ", f[ i ][ j ] );
39         }
40         printf( "\n" );
41     }
42 }
43
44 void recur(int beg, int end)
45 {
46     if( beg > end ) return ;
47
48     if( beg == end )
49     {
50         if( s[ beg ] == '(' || s[ beg ] == ')' )
51         {
52             printf( "()" );
53         }
54         else printf( "[]" );
55     }
56     else
57     {
58         if( pos[ beg ][ end ] == -1 )
59         {
60             if( s[ beg ] == '(' )
61             {
62                 printf( "(" );
63                 recur( beg+1, end-1 );
64                 printf( ")" );
65             }
66             else
67             {
68                 printf( "[" );
69                 recur( beg+1, end-1 );
70                 printf( "]" );
71             }
72         }
73         else
74         {
75             recur( beg, pos[ beg ][ end ] );
76             recur( pos[ beg ][ end ]+1, end );
77         }
78     }
79 }
80
81 int DP()
82 {
83     n = strlen( s );
84     memset( f, 0, sizeof( f ));
85
86     for ( int i = n; i > 0; i -- )
87     {
88         s[ i ] = s[ i-1 ];
89         f[ i ][ i ] = 1;
90     }
91
92     int tmp;
93     for ( int p = 1; p <= n; p ++ )
94     {
95         for ( int i = 1; i <= n-p; i ++ )
96         {
97             int j = i + p;
98             f[ i ][ j ] = maxint;
99             if ( ( s[ i ] == '(' && s[ j ] == ')' ) || ( s[ i ] == '[' && s[ j ] == ']' ) )
100             {
101                 tmp = f[ i+1 ][ j-1 ];
102                 if ( tmp < f[ i ][ j ] )
103                 {
104                     f[ i ][ j ] = tmp;
105                 }
106             }
107             pos[ i ][ j ] = -1;
108             for ( int k = i; k < j; k ++ )
109             {
110                 tmp = f[ i ][ k ] + f[ k+1 ][ j ];
111                 if ( tmp < f[ i ][ j ] )
112                 {
113                     f[ i ][ j ] = tmp;
114                     pos[ i ][ j ] = k;
115                 }
116             }
117         }
118     }
119     return f[ 1 ][ n ];
120 }
121
122 int main()
123 {
124     //while ( scanf("%s", &s ) != EOF ){
125     init();
126     DP();
127     //output();
128     recur( 1, n );
129     printf( "\n" );
130     //}
131     return 0;
132 }
133
134

littlekid@R2 2008-01-09 21:40 发表评论

ACM@PKU——1426（BFS？）

littlekid@R2 — Wed, 09 Jan 2008 06:32:00 GMT

按照lzx大牛推荐的分类，开始写搜索题，发现这道1426是个很典型的BFS，写完交上去，结果RE，原来是队列长度开的不够，于是加长了点，就 125ms过了，可是内存太大，用了8000多k，不知道大牛们是怎么用0ms，40多k过得。。。貌似还有DP的写法？好像还有什么构造法。。。我压根就不知道什么是构造法。。。期待大牛解释。。。
Simbaforrest
2008.1.9

1 #include<iostream>
2 #include<cstring>
3 #include<cmath>
4 using namespace std;
5 int n;
6 const int maxn = 1100000;
7 __int64 q[maxn];
8
9 void BFS()
10 {
11     //init
12     int front,rear;
13     front=rear=0;
14     q[rear]=1;
15     rear++;
16     //sovle
17     __int64 top;
18     while(rear>front)
19     {
20         top = q[front];
21         if(top%n==0)
22             break;
23         top *= 10;
24         q[rear++]=top;
25         q[rear++]=top+1;
26         front++;
27     }
28     //output
29     cout<<top<<endl;
30 }
31
32 int main()
33 {
34     while(cin>>n&&n!=0)
35     {
36         BFS();
37     }
38     return 0;
39 }
40

littlekid@R2 2008-01-09 14:32 发表评论

ACM@PKU——2632（模拟）

littlekid@R2 — Thu, 27 Dec 2007 07:21:00 GMT

摘要: 一次AC了这个模拟题，本来是想用面向对象的思想来写，不过最后写成了这个样子。。。 simbaforrest ... 阅读全文

littlekid@R2 2007-12-27 15:21 发表评论

ACM@PKU——1328（贪心＋排序）

littlekid@R2 — Thu, 27 Dec 2007 07:16:00 GMT

总算过了这个题了。。。。。。
教训：
1。对于qsort的cmp函数的写法要养成好习惯，最好要这么写：

1 int cmp ( const void * a, const void * b)
2 {
3     double ss = (*(point *)a).s -(*(point *)b).s;
4     if (ss > 0 ) return 1;
5     if (ss < 0 ) return -1;
6     if (ss==0)
7     {
8         double pp=(*(point *)a).e -(*(point *)b).e;
9         if (pp > 0) return 1;
10         if (pp < 0) return -1;
11     }
12 }

    否则，如果直接return (*(point *)a).s -(*(point *)b).s;的话，对于一般的int型没什么问题，但是对于浮点数就会出现精度问题了，比如return -0.3就会变成return 0

    2。区间合并的时候要注意上限要不断调整。。。

                                                                   simbaforrest
                                                                   2007/12/27
以下是Wrong Answer代码

1 #include <stdio.h>
2 #include <stdlib.h>
3 #include <string.h>
4 #include <math.h>
5 const int maxn = 1010;
6 int n,d,ans;
7 typedef struct
8 {
9     int x,y;
10     double s,e;
11 }point;
12 point island[maxn];
13
14 int cmp(const void *a, const void *b)
15 {
16     point *c = (point *)a;
17     point *d = (point *)b;
18     if(c->s != d->s)
19         return c->s - d->s;
20     else
21         return c->e - d->e;
22 }
23
24 inline double dist(point a)
25 {
26     return sqrt( d*d - a.y*a.y );
27 }
28
29 void solve()
30 {
31     for(int i=0; i<n; i++)
32     {
33         double l = dist(island[i]);
34         island[i].s = (island[i].x - l);
35         island[i].e = (island[i].x + l);
36
37     }
38     qsort(island,n,sizeof(point),cmp);
39
40     ans = 1;
41     double uplimit = island[0].e;
42     for(int i=1; i<n; i++)
43     {
44         //printf("x=%d , y=%d\n",island[i].x,island[i].y);
45         //printf("s=%lf , e=%lf\n",island[i].s,island[i].e);
46         if(island[i].s - uplimit > 1e-3)
47         {
48             ans++;
49             uplimit = island[i].e;      //就是这里了，错在没有对其它的情况更新uplimit
50         }
51     }
52 }
53
54 int main()
55 {
56     int t=1;
57     while(scanf("%d%d",&n,&d),n&&d)
58     {
59         bool noans = 0;
60         for(int i=0; i<n; i++)
61         {
62             scanf("%d%d",&island[i].x,&island[i].y);
63             if(island[i].y>d)
64                 noans = 1;
65         }
66         if(!noans)
67             solve();
68         else
69             ans = -1;
70         printf("Case %d: %d\n",t++,ans);
71     }
72     return 0;
73 }
74

以下是AC代码

1 #include <stdio.h>
2 #include <stdlib.h>
3 #include <string.h>
4 #include <math.h>
5 typedef struct
6 {
7   double s,e;
8 }point;
9 point island[1010];
10 int n,d,ans;
11 double me;
12
13 int cmp ( const void * a, const void * b)
14 {
15     double ss = (*(point *)a).s -(*(point *)b).s;
16   if (ss > 0 ) return 1;
17     if (ss < 0 ) return -1;
18     if (ss==0)
19   {
20         double pp=(*(point *)a).e -(*(point *)b).e;
21         if (pp > 0) return 1;
22         if (pp < 0) return -1;
23     }
24 }
25
26 void solve()
27 {
28   qsort(island,n,sizeof(island[0]),cmp);
29   ans = 1;
30   me = island[0].e;
31   for(int i=1; i<n; i++)
32   {
33     if(island[i].s > me)
34     {
35       me = island[i].e;
36       ans++;
37     }
38     else
39     {
40       if(island[i].e < me)
41       {
42         me = island[i].e;
43       }
44     }
45   }
46 }
47
48 int main()
49 {
50   int t=1;
51   while(scanf("%d%d",&n,&d),(n!=0)||(d!=0))
52   {
53     bool noans = 0;
54     for(int i=0; i<n; i++)
55     {
56       int x,y;
57       scanf("%d%d",&x,&y);
58       if(y>d || noans == 1)
59       {
60         noans = 1;
61       }
62       else
63       {
64         double l = sqrt( (double)(d*d - y*y) );
65         island[i].s = (double)x-l;
66         island[i].e = (double)x+l;
67       }
68     }
69     if(noans==1)
70     {
71       ans = -1;
72       printf("Case %d: %d\n",t++,ans);
73     }
74     else
75     {
76       solve();
77       printf("Case %d: %d\n",t++,ans);
78     }
79   }
80   return 0;
81 }
82

littlekid@R2 2007-12-27 15:16 发表评论

1002@PKU

littlekid@R2 — Thu, 06 Dec 2007 11:27:00 GMT

摘要: 好久没做题了，今天为了周日的地大比赛，热热身，把pku的1002这个简单题切了，虽然先tle了一次。。。教训：对于这种模拟性质的题，应该尽可能的让思路简单一点，不要想的太复杂；另外，最好一个模块一个模块的写，编写边注释，这样思路比较不容易乱。 ... 阅读全文

littlekid@R2 2007-12-06 19:27 发表评论

POJ1018 Communication System

littlekid@R2 — Sat, 01 Dec 2007 15:10:00 GMT

题目描述：

产品由n个部件组成（n〈= 100），每个部件有b和p 两个属性值，每个部件有m种选择（m〈=100），总产品的B=min{bi} ，P=Σ{pi}，选择各部件，使得最后产品的B/P值最大。

解题思路:

贪心。思路(来自Discuss)

1,获得一个最小和最大带宽:

最小带宽是各个设备最小带宽的最大值,

最大带宽是各个设备最大带宽的最小值.

2,从最小值递增到最大值进行寻找,

计算各种设备价钱的最小值的和,然后计算出一个比值,

如果比值比当前比值大,更换当前比值;

3,重复2直到结束.

for(i=0;i<总共的状态数;i++)

{ for (j=0;j<总的部件数;j++)

{ for(k=0;k<总的选择;k++)

求出满足状态i的，p值最小的部件;

total+=求出来的p；

}

比较求出最大的B[i]/ total 的值；

}

1/********************************************************************
2Author: littlekid
3Created Time: 2007-11-28
4Problem Source: POJ1018
5Description:
6********************************************************************/
7# include <stdio.h>
8
9# define N 110
10# define MAX 342289
11
12int b[ N ][ N ],p[ N ][ N ];
13int m[ N ];
14
15int main()
16{
17    int n;
18    int min_b, max_b;
19    int sum_p, min_p;
20    double max;
21    int T; scanf( "%d", &T );
22    while ( T -- )
23    {
24        max_b = 0; min_b = MAX;
25        scanf("%d",&n);
26        for( int i = 0; i < n; ++ i)
27        {
28            scanf( "%d", &m[i] );
29            for( int j = 0; j < m[ i ]; ++ j )
30            {
31                scanf( "%d %d", &b[ i ][ j ], &p[ i ][ j ] );
32                if ( max_b < b[ i ][ j ] ) max_b = b[ i ][ j ];
33                if ( min_b > b[ i ][ j ] ) min_b = b[ i ][ j ];
34            }
35        }
36        max = 0.00;
37        for( int i = min_b; i <= max_b; ++ i)
38        {
39            sum_p = 0;
40            for( int j = 0; j < n; ++ j)
41            {
42                min_p = MAX;
43                for( int k = 0; k < m[ j ]; ++ k )
44                {
45                    if( b[ j ][ k ] >= i && p[ j ][ k ] < min_p )
46                    {
47                        min_p = p[ j ][ k ];
48                    }
49                }
50                sum_p += min_p;
51            }
52            if( (double)i / (double)sum_p > max )
53            {
54                max = (double)i / (double)sum_p;
55            }
56        }
57        printf( "%.3lf\n", max );
58    }
59    return 0;
60}
61

littlekid@R2 2007-12-01 23:10 发表评论