Description

Running a taxi station is not all that simple. Apart from the obvious demand for a centralised coordination of the cabs in order to pick up the customers calling to get a cab as soon as possible,there is also a need to schedule all the taxi rides which have been booked in advance.Given a list of all booked taxi rides for the next day, you want to minimise the number of cabs needed to carry out all of the rides.
For the sake of simplicity, we model a city as a rectangular grid. An address in the city is denoted by two integers: the street and avenue number. The time needed to get from the address a, b to c, d by taxi is |a - c| + |b - d| minutes. A cab may carry out a booked ride if it is its first ride of the day, or if it can get to the source address of the new ride from its latest,at least one minute before the new ride's scheduled departure. Note that some rides may end after midnight.

Input

On the first line of the input is a single positive integer N, telling the number of test scenarios to follow. Each scenario begins with a line containing an integer M, 0 < M < 500, being the number of booked taxi rides. The following M lines contain the rides. Each ride is described by a departure time on the format hh:mm (ranging from 00:00 to 23:59), two integers a b that are the coordinates of the source address and two integers c d that are the coordinates of the destination address. All coordinates are at least 0 and strictly smaller than 200. The booked rides in each scenario are sorted in order of increasing departure time.

Output

For each scenario, output one line containing the minimum number of cabs required to carry out all the booked taxi rides.

Sample Input

2

2

08:00 10 11 9 16

08:07 9 16 10 11

2

08:00 10 11 9 16

08:06 9 16 10 11

Sample Output

1

2

Source

Northwestern Europe 2004

       根据这道题目的意思，我们可以建一张图，对于两个booked taxi ride，ri和rj如果一辆车能够先完成ri的任务再有时间赶去完成rj的任务，那么就建立一条ri指向rj的边。

       按照题目的要求，要选择最少的taxi来完成这些任务。显然在上面这个例子中，需要安排2辆taxi。结合这个图，可以把题目的要求转化为找出最少的路径条数，使得这些路径覆盖途中所有的边，例如可以选择2条路径1->3->4和1->2就可以覆盖所有的边。也可以选择1->3->4和2（因为2作为初始站，不需要由1转移过来）。对于一条连续的路径vi1->vi2->…vik由于这条路径上的任务实际上是由一辆taxi来完成的，可以吧这条路径退化成两个点vi1->vik。有了这两步建图的步骤以后，问题的求解就可以变为找出顶点集的一个最小子集，使这个顶点子集覆盖所有的边（每条边都至少和一个顶点集的顶点相连）。这个问题就是图的最小点覆盖。再看这张图，还有一些性质能够让我们更好地求出最小点覆盖。这个图是一个有向无环图，没有自环，就可以拆点，把原先建的图变成一张二分图。

可以再图中看出，上面举出的一条路径1->3->4对应了这个二分图中的路径1->3’->3->4’，在这个二分图中就需要求一个最大独立子集（这里的4点就是一条路径的终点，没一条路径即对应有一个终点！）。二分图的最大独立数是总点数与最大匹配数的差值。接下来建图，拆点，求二分图最大匹配就能解决这道题目了。

 1#include <stdio.h>
 2#include <string.h>
 3#include <algorithm>
 4using namespace std;
 5
 6struct Point
 7{
 8    int x,y;
 9};
10struct P
11{
12    int s,e;
13    struct Point s1,s2;
14}p[505];
15int n,g[505][505],match[505];
16bool chk[505];
17
18/**//*int abs(int a)
19{
20    return a < 0 ? -a : a;
21}*/
22bool operator <(const P a, const P b)
23{
24    return a.s < b.s;
25}
26int dfs(int v)
27{
28    int i,t;
29    for(i=0; i<n; i++)
30    {
31        if(!chk[i] && g[v][i])
32        {
33            t=match[i];
34            chk[i]=true;
35            match[i]=v;
36            if(t == -1 || dfs(t)) return 1;
37            match[i]=t;
38        }
39    }
40    return 0;
41}
42int Twomatch()
43{
44    int i,ans=0;
45    memset(match,-1,sizeof(match));
46    for(i=0; i<n; i++)
47    {
48        memset(chk,false,sizeof(chk));
49        if(dfs(i)) ans++;
50    }
51    return ans;
52}
53
54int main()
55{
56    int i,cases,a,b,j,cnt;
57    char temp[10];
58    //freopen("in.txt","r",stdin);
59    scanf("%d",&cases);
60    while(cases--)
61    {
62        scanf("%d",&n);
63
64        for(i=0; i<n; i++)
65        {
66            scanf("%s",temp);
67            scanf("%d%d%d%d",&p[i].s1.x,&p[i].s1.y,&p[i].s2.x,&p[i].s2.y);
68            sscanf(temp,"%d%*[:]%d",&a,&b);
69            p[i].s=a*60+b;
70            p[i].e=p[i].s+abs(p[i].s2.x-p[i].s1.x)+abs(p[i].s2.y-p[i].s1.y);
71        }
72        //sort(p,p+n);
73        cnt=0;
74        memset(g,0,sizeof(g));
75        for(i=0; i<n; i++)
76        {
77            for(j=0; j<n; j++)
78            {
79                if(p[i].e+abs(p[i].s2.x-p[j].s1.x)+abs(p[i].s2.y-p[j].s1.y) < p[j].s && i != j)
80                    g[i][j]=1;
81            }
82        }
83        printf("%d\n",n-Twomatch());
84    }
85    return 0;
86}
87

得“计算机图形学”和“计算机图像处理”是两门很有意思的课程。这学期我们的课程安排还是一贯作风

——课程压缩，把这两门课程压成了一门课程，不仅如此还使用的是内部教材（传说中的内部教材就是把

课程内容进一步精简压缩）。即便在这种情况之下，我还是对计算机图形图像处理充满热情，想多学些东

西，好好地做课程设计。今天临下课前，老师把课程设计的题目布置下来，真令我彻底失望了。布置了20+

个题目，虽说涉及一些军事，但是要求真的很水。后面给出了一系列军事电影，灾难电影大片，做法就是

：
1、看片；
2、截图与PS；
3、写报告与做ppt。
   我想了一下，这里面可能一点理论，一点编程都不会涉及到，这样的课程设计，玩过电脑的人都会做，还

干嘛添在“信息工程”专业的“课程设计”里呢？真是可笑！！！课程都缩水缩到这种程度了，那还开什

么课呢，自欺欺人罢了。稍有点本专业知识的人也不至于会认为计算机图像处理就是玩PS吧。那大学里学

电子工程的毕业后都去修微波炉，通信工程的去卖电话卡，信息工程的就去照相馆做PS好了。
唉……这几天正是新生入学，还看着一批一批的新生往我们宿舍这边走，我心里真是难过，真想跟他们说

，“回去吧，说不定来年还能考个清华。”还有那么多家长，送个孩子上大学多不容易，但也许他们还不知道，他们的儿子要接受这样的教育。想着这些事，心都在痛啊。
   悲……

Description

Input

Output

Sample Input

4
1 2 10
2 3 10
3 3 10
1 3 10
6
1 20 1000
3 25 10000
5 15 5000
22 300 5500
10 295 9000
7 7 6000
8
32 251 2261
123 281 1339
211 235 5641
162 217 7273
22 139 7851
194 198 9190
119 274 878
122 173 8640
0

Sample Output

30
25500
38595

Source

 1for(i=1; i<=365; i++)
 2        {
 3            for(jj=0; jj<hall[i].size(); jj++)
 4            {
 5                for(j=0; j<i; j++)
 6                {
 7                    dp[i][j]=Max(dp[i][j],dp[hall[i][jj].s-1][j]+hall[i][jj].w);
 8                }
 9                for(ii=jj+1; ii<hall[i].size(); ii++)
10                {
11                    dp[i][i]=Max(dp[i][i],dp[hall[i][jj].s-1][hall[i][ii].s-1]+
12                        hall[i][jj].w+hall[i][ii].w);
13                }
14            }
15            for(j=1; j<=i; j++)
16            {
17                dp[i][j]=Max(dp[i-1][j],dp[i][j]);
18                dp[i][j]=Max(dp[i][j-1],dp[i][j]);
19                dp[j][i]=dp[i][j];
20            }
21        }

Description

Input

Output

Sample Input

4
10.00000 0.00000 0.00000 -10.00000 -10.00000 0.00000
22.23086 0.42320 -4.87328 11.92822 1.76914 27.57680
156.71567 -13.63236 139.03195 -22.04236 137.96925 -11.70517
129.400249 -44.695226 122.278798 -53.696996 44.828427 -83.507917

Sample Output

4
6
23
100

Source

题目大意是给出三个点的(x,y)坐标，要求输出一个边数最小的正多边形的边数，使这三个点恰好在

这个正多边形上面。其实这个三角形和这个正多边形是共外接圆，由外接圆的圆心出发，三角形的三

条边可以把圆分成三份，每份圆弧所对应的圆心角分别为arg[0],arg[1]和arg[2]，正多边形把圆弧

分成相等的n份，每份对应的圆心角为2*pi/n。其实三角形的三个角就分别占用了若干等份正多边形

所划分的圆弧，最后也就只要求arg[0],arg[1],arg[2]和2*pi的最大公约数(gcd)即可。但是这里是

个角度都是浮点数，所以还定义一个浮点数的gcd，计算浮点数的gcd可以利用math.h的函数fmod

(x,y)表示x%y。例如3.5%0.3=0.2，x%y的结果为不超过y的一个浮点数。下面写了一个fmod(x,y)自己

的实现。
double fmod(double x, double y)
{
 return x-floor(x/y)*y;
}
有了fmod函数以后，就可以用它来求gcd了！
double fgcd(double a, double b)
{
 double t;
 if(dblcmp(a-b) == 1)  //a>b
 {
  t=a;
  a=b;
  b=t;
 }
 if(dblcmp(a) == 0) return b;
 return fgcd(fmod(b,a),a);
}

       今天去湖大我认为就要避免我们组再出现这种情况，一定要读题，要多想题！大清早坐校车一路风光的到了湖大（长沙今天搞火炬传递预演，人很多，结果校车无视旁人地开了过去）。离比赛还有一个多小时的时间。这时alpc62跟我说，他今天的状态不好，昨晚做topcoder做到很晚才睡。于是找了个地方大睡一阵，醒来后就精神饱满的说今天可以敲题了。

       题目印刷地很乱，分题的时候就个人撕了1/3的题目。Alpc62先拿到了A，用一个log函数过掉了。然后我看题，发现一个中文字符串DP题，我觉得可以做，就跟62说题了。62大敲一阵，我就一直在找题目中的trick，因为我感觉这道题有很多没说清楚的地方，不久程序写完，没出样例，然后我们开始检查，发现题目中有一个错误，于是就跑去网页上看，我的天啊！网页上的描述和我们手上拿到的题目差了这么多，按照clarification上说的一切以网页上的为准，于是我们对着网页上的题，过了样例，一交是WA，提交了打印代码，于是62觉得要换题。这时alpc07读了一道猜数字的题，我们判断是弱题，简单暴搞就行。Alpc07上去敲，结果WA，这下搞得郁闷了。不管我们又换题，我又读了全场最多人过的一道题，我开始还在想DP，跟alpc62说了以后，他毫不犹豫地说，dijkstra嘛，是全年成都热身赛的原题。很快就1A了，过了这时alpc62的人品就暴了，在吸取了前面的教训后，我们打开网页，认真读了上面的题，发现alpc07敲的那到题是因为读入的时候错了，读入以一个非正数结束，而不是以－1结束（这次比赛题目真的很多bug）。于是我们又瞬过了一题。接下来3题做得都很顺，都是alpc62给1A了。最激动的是我们A了6道题以后，开始WA掉的中文字符串DP题被rejudge了，结果alpc62的程序还是1A。题目数瞬间就涨到了7题。这时我们还有一道博弈和连连看模拟题，博弈我推了半天公式，都是WA，其实我到现在都搞不清楚博弈的原理……连连看模拟题，我觉得自己可以做，但是由于题目没有描述清楚，我有很多细节的地方没有考虑清楚，没敲。最后一个小时的时间就是alpc62和alpc07两个人在弄RSA。写了好久，快到比赛结束了，alpc62发现自己没有带模版了，最后这道题没出，比赛结束，我们是7道题。

       今天在比赛中，我基本上没有敲题，在组里面协调分题，注意场上的形势。就在这次的比赛中我觉得读题对于一个队伍来说很重要。特别是想要出1A，1A的时候可以鼓舞队伍的士气，也不会让大家被一道题目给缠住。另外也可以节省很多时间，过题以后，可以抛弃好多的负担，全力投入到下一道题目中去。对于今天比赛这样的题目，读题是关键。题目不是很难的情况下，在读题中可以发现很多容易卡时的细节。比如输入输出格式，数据范围，题目中冗长的废话，特殊情况的说明……这些都是在敲题的时候要注意的。读题读不好在前两次比赛中都吃了很大的亏，今天自认为读题的情况还不错，比赛中间的那段也做得很顺利。除此之外，今天在比赛中我的收获还有就是看alpc62大牛敲题，我觉得他在敲题的时候思路很清楚，脑子想得很快。感觉他敲题的时候就专心的熔入到题目之中了，思维一直都很连贯，而且对自己代码的驾驭能力很强。我觉得这些也是我要在以后的练习中要加强的。

Description

Input

Output

Sample Input

11 6
1 2
1 3
1 4
1 5
2 6
2 7
2 8
4 9
4 10
4 11

Sample Output

2

Hint

Source

 1void search(int v)
 2{
 3    int i,j,k,t;
 4    mark[v]=true;
 5    dp[v][0]=1;
 6    dp[v][num[v]]=0;
 7    for(i=1; i<=n; i++)
 8    {
 9        if(g[v][i] && !mark[i])
10        {
11            search(i);
12            for(j=1; j<=num[v]; j++)
13            {
14                if(dp[v][j] != INF)
15                {
16                    for(k=0; k<=num[i]; k++)
17                    {
18                        if(dp[i][k] != INF)
19                        {
20                            t=dp[v][j-(num[i]-k)];
21                            dp[v][j-(num[i]-k)]=Min(t,dp[v][j]+dp[i][k]);
22                        }
23                    }
24                }
25            }
26        }
27    }
28}
29
30int main()
31{
32    int i,j,a,b;
33    //freopen("in.txt","r",stdin);
34    scanf("%d%d",&n,&m);
35    memset(g,false,sizeof(g));
36    memset(num,0,sizeof(num));
37    for(i=1; i<=n; i++)
38        for(j=1; j<=n; j++)
39            dp[i][j]=INF;
40    for(i=1; i<n; i++)
41    {
42        scanf("%d%d",&a,&b);
43        g[a][b]=g[b][a]=true;
44    }
45    memset(mark,false,sizeof(mark));
46    dfs(1);
47    memset(mark,false,sizeof(mark));
48    search(1);
49    a=INF;
50    for(i=1; i<=n; i++)
51    {
52        //for(j=1; j<=num[i]; j++)
53        //{
54            b=dp[i][m];
55            if(i != 1)
56                b++;
57            if(b < a)
58                a=b;
59        //}
60    }
61    printf("%d\n",a);
62    return 0;
63}

的时候分题，我读DEF，很快我就发现了E是一道水题，上手就敲，测试了几个数据之后就

submit了。遗憾啊，这就是我们组这场比赛唯一的一个1/Y。在中南赛前夜，我还在想有尽

量多的1/Y，一上场这么快就水过了一道题，我还以为今天的题目很简单。当时的心情那个

激动啊……过题后我又立马读D题，看起来很像一道模拟题，我自信地认为这题跟E一样，

马上又开始敲代码，敲着敲着就发现不对了，数据量达到了100000，暴搞的话会超时，我

意识到这道题不光是纯粹的模拟，应该要借助于些数据结构的了。我们组放慢了脚步。

alpc40和alpc43仍在读题，接着alpc40跟我讲C题，700个点中选出三个点，使得这三个点

确定的外接圆半径最大。O(n^3)的时间会超时，于是我又一次不加思索地说“突包”，兴

致勃勃地敲了个突包，结果WA。打印代码，以为是我的突包错了，再改，再WA。这时已经

两个多小时过去了，我们还是一个气球。一次次的WA让我冷静下来想，问题没这么简单，

后来讨论发现先求突包，再枚举点的方法是错的。做了两个多小时的算法从根本上是错的

，当时我就预感到比赛后的结果了。最后敲了个O(n^3)的暴搞，TLE。此时我已经放弃了。

比赛中作为一个主力，我觉得我的表现实在是太差了，没有认真地讨论和分析就敲题，大

部分时间占用着键盘，以致于alpc43整场比赛都没有碰到键盘。组队赛变成了我的个人赛

，并没有发挥三个人的合力。特别是到了最后15分钟，变成了垃圾时间，没题可做了，我

们开始边吃汉堡，边刷rank list……
    总结这次比赛，首先是我，场上的经验还不足。比如在这次比赛中场上出现了没题做

，算法错误等致命的情况时，我完全就不能控制这样的局面，冲动－>失落->放弃，在组队

赛中很忌讳出现这样的情形。比赛的时候和平时做题都不一样，当时脑子就很混乱，再也

没心思想其他的题目了。另外也是自己的实力原因，对题目把握得不好。对于我们组，我

觉得互相的交流和讨论还有待改进，有时说题意，对方很难领会，比赛中的讨论也没出现

有意义的亮点。
    alpcs都在好好地反思反思再反思……也许给我自己的机会并不多，认真做好每一场比

赛，每场比赛都要有收获。

过了一年的努力，今年取得了这个机会。和我同组的还有alpc40和alpc43。我们平时还都

比较了解了。alpc40和我是一个宿舍的，平时做题的交流也比较多，我们两写程序的风格

也差不多（一个老师教的嘛^_^）。我觉得alpc40在做数学题，找规律的题目时还是很快能

找到方法的，在比赛的时候，他比较喜欢自己出数据，敲完题后总是不断地出数据来检验

自己的程序，在校赛中就看出了，虽然他交题的时间不是最早的，因为他一直在出数据测

试自己的程序，一直测到自己认为没有问题了，才提交，很大概率出1/Y的。所以尽管交题

不快，但因错得少，罚时少，校赛时在同样题目数的人中还是排在了前面。我觉得这点非

常好，在明天的比赛中，我们首先要求稳。我觉得我们的实力绝对不至于强到把所有的题

目都做出来，也不见得会比别人多出题，所以在很多同样题目数的人中，还是要拼罚时的

。这就需要在比赛中做的稳，争取尽量多的1/Y。我也要克服平时比较急躁的习惯，切忌不

要一出样例就交，回顾一下自己的程序，测试一下数据，查找错误。这两次比赛看了

alpc43的代码，我觉得他的代码实在是很乱，很多缩进，换行都用得不规范，写程序的时

候容易造成思路不清晰，在检查程序的时候也很难发现错误，会浪费很多时间。我觉得比

赛中，给alpc43做些代码量不大，但是思路能够出来得比较清晰的题目。至于我，我觉得

应该担起大量的代码任务，在组里，我的代码速度还可以。可以写点代码量大的模拟题，

尽量快地AC，好为我们组节省时间。另外，一些设计算法，数据结构的题目（网络流，二

分图，高精度，线段树，计算几何等），我也要敲敲，争取能冲出更多的题。
    从今天的热身赛来看，我的状态一点都不好。可能是这个星期，又要做题，又要考试

，还要组织数据库的复习，有点搞得太累了。就写这么点了，今晚休息好点，但愿明天能

保持最佳的状态^_^

Description

The rotation game uses a # shaped board, which can hold 24 pieces of square blocks (see Fig.1). The blocks are marked with symbols 1, 2 and 3, with exactly 8 pieces of each kind.

Initially, the blocks are placed on the board randomly. Your task is to move the blocks so that the eight blocks placed in the center square have the same symbol marked. There is only one type of valid move, which is to rotate one of the four lines, each consisting of seven blocks. That is, six blocks in the line are moved towards the head by one block and the head block is moved to the end of the line. The eight possible moves are marked with capital letters A to H. Figure 1 illustrates two consecutive moves, move A and move C from some initial configuration.

Input

The input consists of no more than 30 test cases. Each test case has only one line that contains 24 numbers, which are the symbols of the blocks in the initial configuration. The rows of blocks are listed from top to bottom. For each row the blocks are listed from left to right. The numbers are separated by spaces. For example, the first test case in the sample input corresponds to the initial configuration in Fig.1. There are no blank lines between cases. There is a line containing a single `0' after the last test case that ends the input.

Output

For each test case, you must output two lines. The first line contains all the moves needed to reach the final configuration. Each move is a letter, ranging from `A' to `H', and there should not be any spaces between the letters in the line. If no moves are needed, output `No moves needed' instead. In the second line, you must output the symbol of the blocks in the center square after these moves. If there are several possible solutions, you must output the one that uses the least number of moves. If there is still more than one possible solution, you must output the solution that is smallest in dictionary order for the letters of the moves. There is no need to output blank lines between cases.

Sample Input

1 1 1 1 3 2 3 2 3 1 3 2 2 3 1 2 2 2 3 1 2 1 3 3

1 1 1 1 1 1 1 1 2 2 2 2 2 2 2 2 3 3 3 3 3 3 3 3

0

Sample Output

AC

2

DDHH

2

Source

Shanghai 2004

图中的#字格的4条竖线，可以按8个方向倒转里面的数字方块，当中间的8个数字方块是同一个数字时，游戏结束。这道题就要求搜索一个最短路径，倒转8个方向使得中间8个数字相等。这道题目看起来很像一道单纯的BFS，看了POJ里面说BFS会爆内存，我没试，估计写得好的也爆不了。但是估计写BFS还要涉及到状态的判重，程序写起来也不方便。我用了迭代加深的搜索方法。第一次接触这个算法，我说一下我的理解：

       原来我很不理解迭代加深，搜索的深度一层一层地加，在后面的某一深度限制下搜索，必定会搜到前面深度所能搜到的结果，这会造成重复搜索。基于这点，我一直都认为迭代加深搜索的方法很冗余，当然也是自己从来都没有动手试过。像这道题就给我的收获不少，有的时候选择一定的策略进行搜索，我们是很难确定解所在状态空间的深度的，有时可能解的深度不大，但整个状态空间的深度很大，盲目的dfs搜索在状态空间里就有可能会越陷越深，迟迟出不了解，同时整个状态空间的宽度也很大，用BFS可能就会爆空间。迭代加深搜索恰恰是取了一个折中。利用了dfs的优势，限制了搜索的深度，避免了出现无解的境地。由于深度是逐个增加的，当搜到一个解后就退出，所以避免了BFS中判重的一步操作，当然在迭代深搜的过程中，还可以加入剪枝，可以优化程序。但是我的程序在POJ上还不快，还要找找原因，也许还有优化。下面是一些关键代码：

for(limit=0; ;limit++)
        {
            if(dfs(start,0))
            {
                if(limit == 0)
                {
                    printf("No moves needed\n");
                }
                else
                {
                    for(i=0; i<limit; i++)
                    {
                        printf("%c",'A'+pre[i]);
                    }
                    printf("\n");
                }
                printf("%d\n",rlt);
                break;
            }
        }
///迭代过程
int dfs(struct S now, int depth)
{
    int c1,c2,c3;
    struct S st;
    test(now,c1,c2,c3);
    if(c1 == 8)
    {
        rlt=1;
        return 1;
    }
    else if(c2 == 8)
    {
        rlt=2;
        return 1;
    }
    else if(c3 == 8)
    {
        rlt=3;
        return 1;
    }
    if(depth == limit)
        return 0;
    if(8-c1 > limit-depth && 8-c2 > limit-depth && 8-c3 > limit-depth)
        return 0;
    st=NewStateA(now);
    pre[depth]=0;
    if(dfs(st,depth+1))
        return 1;
    st=NewStateB(now);
    pre[depth]=1;
    if(dfs(st,depth+1))
        return 1;
    st=NewStateC(now);
    pre[depth]=2;
    if(dfs(st,depth+1))
        return 1;
    st=NewStateD(now);
    pre[depth]=3;
    if(dfs(st,depth+1))
        return 1;
    st=NewStateE(now);
    pre[depth]=4;
    if(dfs(st,depth+1))
        return 1;
    st=NewStateF(now);
    pre[depth]=5;
    if(dfs(st,depth+1))
        return 1;
    st=NewStateG(now);
    pre[depth]=6;
    if(dfs(st,depth+1))
        return 1;
    st=NewStateH(now);
    pre[depth]=7;
    if(dfs(st,depth+1))
        return 1;
    return 0;
}
///深搜

Source from： http://acm.pku.edu.cn/JudgeOnline/problem?id=2676

Sudoku中文名“数独”游戏，游戏规则是在一个9×9的方格中填入1－9这9个数字，9×9的大方格又被划分成了9个3×3的小方格，要求填入的这1－9这9个数字中，在每一行，每一列及每一个小方格中都不能重复出现。

在pku上，我暴搜的方法，将每个空格的位置几下，然后用dfs往里填数，不符合条件的就回溯。方法如下：

Source

Problem: 2676 User: alpc60

Memory: 80K Time: 1171MS

Language: C++ Result: Accepted

Source

#include <stdio.h>

#include <string.h>

struct P

{

       int x,y,num;

}point[100];

int map[10][10],count;

bool mr[10][10],mc[10][10],mm[10][10];

int dfs(int n);

int find(int x, int y);

int main()

{

       int i,j,cases;

       //freopen("2676.txt","r",stdin);

       scanf("%d",&cases);

       while(cases--)

       {

              count=0;

              memset(mc,false,sizeof(mc));

              memset(mr,false,sizeof(mr));

              memset(mm,false,sizeof(mm));

              memset(map,0,sizeof(map));

              for(i=1; i<=9; i++)

                     for(j=1; j<=9; j++)

                     {

                            scanf("%1d",&map[i][j]);

                            if(map[i][j]==0)

                            {

                                   point[count].x=i;

                                   point[count].y=j;

                                   point[count].num=0;

                                   count++;

                            }

                            else

                            {

                                   mr[i][map[i][j]]=true;

                                   mc[j][map[i][j]]=true;

                                   mm[find(i,j)][map[i][j]]=true;

                            }

                     }

              dfs(0);

              //{

                     for(i=0; i<count; i++)

                            map[point[i].x][point[i].y]=point[i].num;

                     for(i=1; i<=9; i++)

                     {

                            for(j=1; j<=9; j++)

                            {

                                   printf("%d",map[i][j]);

                            }

                            printf("\n");

                     }

              //}

       }

       return 0;

}

int dfs(int n)

{

       int i,t;

       if(n>=count)

              return 1;

       t=find(point[n].x,point[n].y);

       for(i=1; i<=9; i++)

       {

              if(!mr[point[n].x][i] && !mc[point[n].y][i] && !mm[t][i])

              {

                     mr[point[n].x][i]=true;

                     mc[point[n].y][i]=true;

                     mm[t][i]=true;

                     point[n].num=i;

                     if(dfs(n+1))

                            return 1;

                     mr[point[n].x][i]=false;

                     mc[point[n].y][i]=false;

                     mm[t][i]=false;

                     point[n].num=0;

              }

       }

       return 0;

}

int find(int x, int y)

{

       int r,c;

       r=x%3?(x/3+1):(x/3);

       c=y%3?(y/3+1):(y/3);

       return (r-1)*3+c;

}

1273 Drainage Ditches

这是一道比较单纯的网络流，题目要求只要求出源点到汇点的最大流就行了，而并不需要任何的建模抽象的东西，唯一一点要注意的是，要考虑有重边的情况。

这里我用的是增广路法求的最大流，流从源点s出发，用BFS找到一条增广路径，然后找这条路径上的最小值min，对增广路进行扩展，每一次扩展会使得f[pre[i]][i]的值增大，那么它的反向路径f[i][pre[i]]的值会减小，一直进行下去，直到找不到增广路为止，算法结束。

Source

Problem Id:1273 User Id:linyangfei

Memory:240K Time:15MS

Language:C++ Result:Accepted

Source

#include <stdio.h>

#include <string.h>

int n,m,pre[205];

int f[205][205];

bool mark[205];

int bfs();

__int64 MaxFlow();

int main()

{

       int i,s,e,c;

       //freopen("1273.in","r",stdin);

       while(scanf("%d%d",&m,&n)!=EOF)

       {

              memset(f,0,sizeof(f));

              for(i=0; i<m; i++)

              {

                     scanf("%d%d%d",&s,&e,&c);

                     if(f[s-1][e-1]==0)

                            f[s-1][e-1]=c;

                     else

                            f[s-1][e-1]+=c;

              }

              printf("%I64d\n",MaxFlow());

       }

       return 0;

}

int bfs()

{

       int q[205],qt=0,qh=1,i,x,min;

       q[qt]=0;

       mark[0]=true;

       while(qt<qh)

       {

              x=q[qt];

              if(x==n-1)

              {

                     min=100000000;

                     for(i=n-1; pre[i]!=-1; i=pre[i])

                            min=f[pre[i]][i]<min?f[pre[i]][i]:min;

                     return min;

              }

              for(i=1; i<n; i++)

              {

                     if(!mark[i] && f[x][i]>0)

                     {

                            q[qh++]=i;

                            mark[i]=true;

                            pre[i]=x;

                     }

              }

              qt++;

       }

       return 0;

}

__int64 MaxFlow()

{

       int i,min;

       __int64 maxflow=0;

       memset(mark,0,sizeof(mark));

       for(i=0; i<n; i++)

              pre[i]=-1;

       while(min=bfs())

       {

              for(i=n-1; pre[i]!=-1; i=pre[i])

              {

                     f[pre[i]][i]-=min;

                     f[i][pre[i]]+=min;

              }

              maxflow+=min;

              memset(mark,0,sizeof(mark));

              for(i=0; i<n; i++)

                     pre[i]=-1;

       }

       return maxflow;    

}

1149 PIGS

       也是一道很经典的网络流的题目，题目大意是Mirko有M个猪圈，猪圈里面有一定数量的猪，但他没有钥匙，而只有来买猪的顾客才会有一些特定房间的钥匙，每次顾客来之前，都跟Mirko预约好，所以Mirko的任务就是找出一个计划，使他能卖出最多数量的猪。对于每位顾客，Mirko可以选择卖出猪的数量，也可以在该顾客打开的猪圈间任意调整猪的数量，每个猪圈的容量无限大。

       我觉得这个问题的一个关键点是建模，如何建立一个网络流的模型很关键。我把所有的猪圈统一看成一个大的源点S，把每个顾客看成是一个节点，然后再人工地添加一个汇点。这样可以得出下面的路径关系。

1、 在先到的顾客和后到的顾客之间有一条路径，指向后到的顾客，这条路径的容量无限大。

2、 在源点有指向各个顾客的路径，路径的容量为顾客拥有的钥匙所能打开的猪圈的猪的总量，注意，当两个顾客拥有同一把钥匙的时候，猪圈的数量只能加到一个顾客节点的路径上，不能重复加，他们之间的转移关系就靠1中两顾客间容量无限大的路径来实现。

我想有了这两点，把网络流的模型建立起来后，求解的算法按照1273的模版就应该很容易了。

#include <stdio.h>

#include <string.h>

const int INF=100000000;

int f[105][105],pig[1005],key[1005][105],pre[105];

bool mark[105];

int m,n;

int bfs();

int MaxFlow();

int main()

{

       int i,j,c,p,k;

       //将猪圈看作一个大的源点0，再外加一个汇点n+1

       freopen("1149.txt","r",stdin);

       while(scanf("%d%d",&m,&n)!=EOF)

       {

              for(i=1; i<=m; i++)

                     scanf("%d",&pig[i]);

              memset(f,0,sizeof(f));

              memset(key,0,sizeof(key));

              for(i=1; i<=n; i++)

              {

                     scanf("%d",&c);                         //每位顾客拥有钥匙的数量

                     for(j=1; j<=c; j++)

                     {

                            scanf("%d",&p);                  //输入每把钥匙的编号

                            f[0][i]+=pig[p];

                            key[p][i]=1;

                            pig[p]=0;

                     }

                     scanf("%d",&c);                         //输入每位顾客需要猪的数量

                     f[i][n+1]=c;

              }

              for(i=1; i<=m; i++)

                     for(j=1; j<=n; j++)

                     {

                            if(key[i][j])

                                   for(k=j+1; k<=n; k++)

                                   {

                                          if(key[i][k])

                                                 f[j][k]=INF;

                                   }

                     }

              printf("%d\n",MaxFlow());

       }

       return 0;

}

int bfs()

{

       int q[205],qt=0,qh=1,i,x,min;

       q[qt]=0;

       mark[0]=true;

       while(qt<qh)

       {

              x=q[qt];

              if(x==n+1)

              {

                     min=100000000;

                     for(i=n+1; pre[i]!=-1; i=pre[i])

                            min=f[pre[i]][i]<min?f[pre[i]][i]:min;

                     return min;

              }

              for(i=1; i<=n+1; i++)

              {

                     if(!mark[i] && f[x][i]>0)

                     {

                            q[qh++]=i;

                            mark[i]=true;

                            pre[i]=x;

                     }

              }

              qt++;

       }

       return 0;

}

int MaxFlow()

{

       int i,min;

       int maxflow=0;

       memset(mark,0,sizeof(mark));

       for(i=0; i<=n+1; i++)

              pre[i]=-1;

       while(min=bfs())

       {

              for(i=n+1; pre[i]!=-1; i=pre[i])

              {

                     f[pre[i]][i]-=min;

                     f[i][pre[i]]+=min;

              }

              maxflow+=min;

              memset(mark,0,sizeof(mark));

              for(i=0; i<=n+1; i++)

                     pre[i]=-1;

       }

       return maxflow;    

}

       这是我的第一个DP，题目的意思很简单，在一个矩阵里面找它的子矩阵，使得子矩阵数值之和到达最大。其实就是最大子段和问题在二维空间上的推广。先说一下一维的情况吧。设有数组a0,a1…an,找除其中连续的子段，使它们的和达到最大。最开始的想法，是枚举矩阵的长度，计算每个子矩阵的和，然后比较得出最大值，这样要消耗的时间为O(n)。让我们再想想，如果这个序列的每一个数都是整数，那么它们的最大子段和就是把所有的数相加。所以我们想要尽可能多地找到正数相加。在序列中有负数的情况下，从头开始扫描数组，把正数都相加，这其中可能会有负数，一种情况是：负数和减小子段和，但这时子段和仍然为正，用sum记录下连续子段和的最大值，继续想后扫描，因为后面有可能出现更大的正数的情况，会使和比原来没加负数之前更大；第二种情况是：加入一个负数后，是这个连续的子段和的值变成了负数，这时就要抛弃该负数以及该负数之前的所有序列，因为前面若有子段与后面构成了连续的子段，则这个子段一定会包括这个负数，而在这个负数之前的序列的和是个负数，那么这个子段的和一定不是最大的子段和。抛弃这个负数之前的序列后，子段和从这个负数后面的第一个数算起，继续扫描。

//一维数组求最大字段

int submax1(int a[], int n)

{

       int b=0;

       int bn=-32767;

       int i;

       int sum=0;

       for(i=0; i<n; i++)

       {

              if(b>0)

              {

                     b+=a[i];

              }

              else if(a[i]>bn && a[i]<0)

              {

                     bn=a[i];

                     b=a[i];

              }

              else

              {

                     b=a[i];

              }

              if(b>sum)

              {

                     sum=b;

              }

       }

       if(sum==0)

              return bn;

       else

              return sum;

}

其中变量b就是记录当前扫描过的子段和的，而sum记录的是子段和的最大值

二维的情况：

       这里我使用了一个很简单的做法，在二维数组a[i][j]里面枚举第一维的长度k，然后得到一个k*n的子矩阵，把这个子矩阵的每一列数值相加，就把这个二维数组转化成了一维，再调用函数int submax1(int a[], int n)，就计算得出最大值。

总结：感觉我做这道题目还不是很像DP，只有在求一维情况下的sum记录最大值，以及在扫描是计算的子段和b，代表了某数前面连续的最大子段和。

二、1579 Function Run Fun

这肯定是一个处心积虑的函数，没看出它有什么实际的用处

Consider a three-parameter recursive function w(a, b, c):
if a <= 0 or b <= 0 or c <= 0, then w(a, b, c) returns: 1
if a > 20 or b > 20 or c > 20, then w(a, b, c) returns: w(20, 20, 20)
if a < b and b < c, then w(a, b, c) returns: w(a, b, c-1) + w(a, b-1, c-1) - w(a, b-1, c)
otherwise it returns: w(a-1, b, c) + w(a-1, b-1, c) + w(a-1, b, c-1) - w(a-1, b-1, c-1)

这本身就是一个递归函数，要是按照函数本身写递归式，结果肯定是TLE，这里我开了一个三维数组，从w(0,0,0)开始递推，逐步产生到w(20,20,20)的值，复杂度O(n^3)

总结：这道题是很地道的DP，因为它的子问题实在是太多了，但还是属于简单题目的范畴，就像把fabonacci函数增加到三维，限制条件多点而已，而实际上的做法都一样。

三、1080 Humman Gene Function

应该说这是一道比较经典的DP，两串基因序列包含A、C、G、T，每两个字母间的匹配都会产生一个相似值，求基因序列（字符串）匹配的最大值。

感觉这题有点像求最长公共子序列。只不过把求最大长度改成了求最大的匹配值。用二维数组m[i][j]记录字符串a中的第i个字符与字符串b中的第j个字符匹配所产生的最大值。若字符串a的长度为la，字符串b的长度为lb，初始时m[la][k](0<=k<=lb-1),这里即为字符串a的末尾与b中的字符匹配，因为超过了字符串a的长度，所以匹配的时候只能时以空格’-’匹配。同理可产生m[k][lb](0<=k<=la-1)，的所有值，再以此往前递推，其状态转移方程为

m[i][j]=max{map[i][j]+m[i+1][j+1],m[‘-‘][j]+m[i][j+1],m[i][‘-’]+m[i+1][j]}

所以最后m[0][0]即为所求。

四、2533 Longest Ordered Subsequence

       很早以前就看过这题，求最大递增序列，那时刚刚晓得什么叫“动态规划”，是《算法设计与分析》（王晓东）上的一道习题，开始不会做。后来想了一种很笨的办法，用了O(n^2)的时间，还附加了n^2的空间。看了世铭的两种方法，一种是O(n^2),一种是O(nlogn)。两种方法核心的方法都一样，用一个n大小的一维空间(a[n])，a[i]表示子串长度为i时所有子串最大值中的最小值，因为要找一个i长度的子串，那么a[i]的值至少要比长度为i-1子串中的一个最末位的值要大。之所以会有两种时间复杂度的差别，就是在查找i-1长度的末尾值中的最小值的时候，前者是线性的搜索，后者是用的二分搜索，提高了时间效率。另外说一下这题的变形吧，1631 Briging signals，是有很多路由器搭线，要求求出互不相交的搭配的最大个数。细细分析一下题目，只要被匹配的路由器序号是一个递增的序列，则他们的连线就不会相交，就把这题转化为求最大递增序列的问题。但需要注意的是这题的问题规模n达到了40000，Time Limit :1000MS，所以在这里要选用刚才提到的O(nlogn)的算法，才不会导致TLE。

五、1014 Dividing

       实际上早就看到这题了，那时对ACM的认识还很幼稚，刚学完程序设计，学会怎么用递归，也不看题目的条件，反正就是六种marble，写了个递归的程序，测试数据当然能通过，但其结果肯定是TLE了。又过了一段时间，有了点时间效率的观念，写了个枚举法计算总和的1/2的可达性，不过还是有很多情况我都没有考虑到，结果WA了。到现在学DP，再来看想想这题，其实还有更好的解法。也是计算总和的1/2(sum)的可达性，如果marble的总数是n，则DP算法的时间复杂度可以达到O(n*sum)。用一个一维数组标记从0－sum所有加和的可达性，对于一颗宝石的价值i，数组a[j]==true，表示和为j可达，那么可得出

a[i+j]=true,即i+j的值可达。循环以致于用完所有的宝石，观察a[sum]的值，true即为这些宝石可分，反之不可分。

       六、2192 Zipper

       又是一道字符串的动态规划题目，简述一下：给出三个字符串，s1,s2,s3，s3的长度为s1与s2长度之和，判断s1，s2是否为s3的不重合的公共子序列。其实就是判别公共之序列的升级版，把原来的一对一，改成了一对二。我用一个二维数组mark[i][j]记录s1中的第i个字符以及s2中的第j个字符能否与s3[i+j]想匹配。

       If(s1[i]==s3[i+j]) mark[i+1][j]=true;//s1中的第i个字符匹配，则s1串向后移一个字符

       If(s2[j]==s3[i+j]) mark[i][j+1]=true;//s2中的第j个字符匹配，则s2串向后移一个字符

这样用O(n^2)的时间，递推能产生mark[c1][c2]的值，值为true输出即能够全部匹配。

       七、2576 Tug of War

       我觉得非常有必要做的一道题目。这道题目看似很简单，实质就是n个数，将其分成两堆，两堆数量的差距不超过1，并且使这两堆数字之和最接近。是一道动态规划题目，看起来简单是因为受了1014题的影响，但这题两堆的数目是确定的，一堆是n/2个，另一堆则是n-n/2个,而1014题是不受加和数目的影响的。这题也不同与多米勒骨牌那题，因为那题中各个数字之间是一一对应的。苦想了一天没有结果，看来这题还要寻求其它的方法。这题不是我自己想除来的，看了alpc02的代码，自己又照自己的理解重写了一遍。

       记录状态是用一个二维数组，mark[i][j]表示i个数相加，其值能否达到j，如果能mark[i][j]的为true。对于一个输入的数w，修改i个数的每一种状态，其状态转移方程：

       If(m[i][j]) then m[i][j+w]=true;//j+w的值可由j的值加得

由后往前修改每一个i下的可达值。那么最后就只要再n/2行中找出m[n/2][j]的最大值（j<=total/2），这就是两堆之和最接近的一组数值。

       八、2441 Arrange the Bulls

       这题里我看到了动态规划的一种新的方法。每头牛有自己喜欢的篮球场，我们的任务就是安排这些牛到它们喜欢的篮球场去，然后计算所有合理的解的数量（篮球场的数目最多20个）。显然，要找到一个解，很容易就能搜出，但是要求所有解的数量，如果再用搜索的方法，在时间上是不堪忍受的。这里用了一种新的方法（对于我来说是一种新方法^_^）。用二进制数记录当前篮球场使用的状态，“1”表示未分配，“0”表示已分配，每个篮球场与每个数位相对应。所以20个篮球场就总共需要一个1<<20的数组来记录所有生成的状态。想到这里，我觉得这题基本上已经解决一半了，剩下的就是如何进行状态转移，用的就是二进制运算。我觉得我在这个方面一点都不熟悉，不会写，看了别人的代码，然后自己仿写了。

一种是用滚动数组，这种方法占用时间空间都较大，另一种是状态压缩的DP，方法比较巧妙。呵呵，要讲得更深点，等我变成牛人在续吧……

       九、2738 Two Ends

       有点想博弈的题目，我事用dp来做的。有一组数，两个人分别轮流从数组两头取数，第一个取数的人可以选用任意的策略，第二个人则要一直使用贪心策略。问最后第一个人所取得的数字之和比第二个人取得的数字之和最多多多少。

       很容易想到DP，第二个人的取数规则是一定的，只有第一个个人可以选择，那么在第一个人取数的时候就有状态转移方程，dp[i][j]表示前面是第i个数后面是第j个数的时候第一个人所能得到数字和的最大值。

if(dp[i][j]+a[i]>dp[i+1][j])

                                   dp[i+1][j]=dp[i][j]+a[i];              //取前面的数

                            if(dp[i][j]+a[j]>dp[i][j-1])

                                   dp[i][j-1]=dp[i][j]+a[j];        //取后面的数

那么第二个人的状态转移就相对比较好确定了：

if(a[i]<a[j] && dp[i][j]!=-1 && dp[i][j]>dp[i][j-1])

                            dp[i][j-1]=dp[i][j];

                     if(a[i]>=a[j] && dp[i][j]!=-1 && dp[i][j]>dp[i+1][j])

                            dp[i+1][j]=dp[i][j];

最后一步只需比较dp[i][i]的值，选其中最大的出来就行了^_^