潘锦的空间 » 动态规划 https://www.phppan.com SaaS SaaS架构 团队管理 技术管理 技术架构 PHP 内核 扩展 项目管理 Sat, 25 Apr 2026 00:56:17 +0000 zh-CN hourly 1 https://wordpress.org/?v=3.9.40 邮票面值设计 https://www.phppan.com/2010/05/postage-stamp/ https://www.phppan.com/2010/05/postage-stamp/#comments Thu, 06 May 2010 01:24:23 +0000 http://www.phppan.com/?p=37 【问题描述】
【描述 Description 】

　　给定一个信封，最多只允许粘贴N张邮票，计算在给定M（N+M<=10）种邮票的情况下（假定所有的邮票数量都足够）,如何设计邮票的面值，能得到最大max ，使得1～max之间的每一个邮资值都能得到。 例如，N=3，M＝2，如果面值分别为1分、4分，则在l分～6分之间的每一个邮资值都能得到（当然还有8分、9分和12分）：如果面值分别为1分、3分，则在1分～7分之间的每一个邮资值都能得到。可以验证当N=3，M＝2时，7分就是可以得到连续的邮资最大值，所以MAX=7，面值分别为l分、3分。 【样例输入】 共一行，两个整数，分表为N与M的值。 【输入格式 Input Format 】 一行，分别为N,M。 【输出格式 Output Format 】 两行。 第一行为m种邮票的面值，按升序排列，各数之间用一个空格隔开。 第二行为最大值。 【样例输入 Sample Input 】 3 2 【样例输出 Sample Output 】 1 3 MAX=7 算法分析 深搜加DP 栈记录所用邮票的面值 每次面值的搜索的范围为：上一次使用的邮票面值+1 to 上一次连续达到的最大值+1 然后DP，记录达到每个面值用的最少邮票数，不断更新最优解 注意要从第1张邮票开始，否则要出错 【代码】 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69

#include <stdio.h>
 
int a[11], ans[11];
int b[1001];
int n, m, max;
 
int dp(int i)
{
       int j, k;
 
       for (j = 1; j < 1001; j++)
              b[j] = 9999;
 
       for (j = 1; j <= i; j++)
              b[a[j]] = 1;
       j = 0;
 
       do
       {
              j++;
 
              for (k = 1; k <= i; k++)
                     if (j > a[k] && b[j - a[k]] + 1 < b[j])
                            b[j] = b[j - a[k]] + 1;
 
       }while (b[j] <= m);
       return j;
}
 
void search(int i)
{
       int j, k;
 
       if (i > n)
       {
              if (dp(i - 1) - 1 > max)
              {
                     for (j = 1; j <= 10; j++)
                            ans[j] = a[j];
                     max = dp(i - 1) - 1;
              }
              return;
       }
       j = dp(i - 1);
 
       for (k = j ; k >= a[i - 1] + 1; k--)
       {
              a[i] = k;
              search(i + 1);
       }
}
 
int main()
{
 
       int i;
       scanf("%d%d", &m, &n);
 
       max = 0;
       a[1] = 1;
       search(2);
 
       for (i = 1; i <= n; i++)
              printf("%d ", ans[i]);
 
       printf("\n");
       printf("MAX=%d\n", max);
       return 0;
}
]]> https://www.phppan.com/2010/05/postage-stamp/feed/ 0 猫狗大战 https://www.phppan.com/2010/04/cat-dog/ https://www.phppan.com/2010/04/cat-dog/#comments Sat, 10 Apr 2010 02:11:41 +0000 http://www.phppan.com/?p=40 问题描述
【描述 Description】
　　新一年度的猫狗大战通过SC(星际争霸)这款经典的游戏来较量，野猫和飞狗这对冤家为此已经准备好久了，为了使战争更有难度和戏剧性，双方约定只能选择Terran(人族)并且只能造机枪兵。

　　比赛开始了，很快，野猫已经攒足几队机枪兵，试探性的发动进攻；然而，飞狗的机枪兵个数也已经不少了。野猫和飞狗的兵在飞狗的家门口相遇了，于是，便有一场腥风血雨和阵阵惨叫声。由于是在飞狗的家门口，飞狗的兵补给会很快，野猫看敌不过，决定撤退。这时飞狗的兵力也不足够多，所以没追出来。

　　由于不允许造医生，机枪兵没办法补血。受伤的兵只好忍了。555－
　　现在，野猫又攒足了足够的兵力，决定发起第二次进攻。为了使这次进攻给狗狗造成更大的打击，野猫决定把现有的兵分成两部分，从两路进攻。由于有些兵在第一次战斗中受伤了，为了使两部分的兵实力平均些，分的规则是这样的：1）两部分兵的个数最多只能差一个；2）每部分兵的血值总和必须要尽可能接近。现在请你编写一个程序，给定野猫现在有的兵的个数以及每个兵的血格值，求出野猫按上述规则分成两部分后每部分兵的血值总和。

【输入格式 Input Format】
第一行为一个整数n(1<=n<=200)，表示野猫现在有的机枪兵的个数。以下的n行每行一个整数，表示每个机枪兵的血格(1<=ai<=40)。 【输出格式 Output Format 】 只有一行，包含两个数，即野猫的每部分兵的血值总和，较小的一个值放在前面，两个数用空格分隔。 【样例输入 Sample Input 】 3 35 20 32 【样例输出 Sample Output】 35 52 【算法分析】 1 to n div 2为前一半数，n div 2+1 to n为后一半数之后枚举a[i],a[j]看是否可以交换 代码 方法一： 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58

#include <stdio.h>
 
int abs(int t)
{
 
       if (t < 0)
              return -t;
       else
              return t;
}
 
int main()
{
 
       int a[201], b[201];
       int n, i, j, l1, l2, sum1 , sum2, temp;
 
       scanf("%d", &n);
 
       l1 = n / 2;
       l2 = n - l1;
       sum1 = 0;
       sum2 = 0;
 
       for (i = 1; i <= l1; i++)
       {
              scanf("%d", &a[i]);
              sum1 += a[i];
       }
 
       for (i = 1; i <= l2; i++)
       {
              scanf("%d", &b[i]);
              sum2 += b[i];
       }
 
       for (i = 1; i <= l1; i++)
       {
              for (j = 1; j <= l2; j++)
              {
                     if (abs((sum1 + b[j] - a[i]) - (sum2 + a[i] - b[j])) < abs(sum1 - sum2))
                     {
                            sum1 = sum1 + b[j] - a[i];
                            sum2 = sum2 + a[i] - b[j];
                            temp = a[i];
                            a[i] = b[j];
                            b[j] = temp;
                     }
              }
       }
 
       if (sum1 < sum2)
              printf("%d %d\n", sum1, sum2);
       else
              printf("%d %d\n", sum2, sum1);
 
       return 0;
}

方法二：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46

Const
maxn=200;
maxm=8000;
Var
f:array[0..maxn,0..maxm] of boolean;
 
n,ans,mid:integer;
d:array[1..maxn] of integer;
 
Procedure Init;
var i:integer;
begin
　　fillchar(f,sizeof(f),false);
　　f[0,0]:=true;
　　ans:=0;
　　readln(n);
　　for i:=1 to n do readln(d[i]);
　　for i:=1 to n do ans:=ans+d[i];
　　mid:=ans div 2;
end;
 
Procedure Work;
var i,j,k:integer;
 
begin
　　for i:=1 to n do
　　  for k:=i downto 1 do
　　　　for j:=mid-d[i] downto 0 do
　　　　  if f[k-1,j] then f[k,j+d[i]]:=true;
end;
 
Procedure Print;
 
var i,j:integer;
begin
　　i:=0;j:=0;
　　while (not f[n div 2,mid+j]) do dec(j);
　　j:=mid+j;
　　writeln(j,' ',ans-j);
end;
 
BEGIN
init;
work;
print;
END.
]]> https://www.phppan.com/2010/04/cat-dog/feed/ 0 三取方格数 https://www.phppan.com/2010/02/three-take-the-check-number/ https://www.phppan.com/2010/02/three-take-the-check-number/#comments Wed, 03 Feb 2010 08:18:32 +0000 http://www.phppan.com/?p=47 【问题描述】
背景 Background
JerryZhou同学经常改编习题给自己做。

这天，他又改编了一题。。。。。

【描述 Description】
设有N*N的方格图，我们将其中的某些方格填入正整数，

而其他的方格中放入0。
某人从图得左上角出发，可以向下走，也可以向右走，直到到达右下角。
在走过的路上，他取走了方格中的数。（取走后方格中数字变为0）
此人从左上角到右下角共走3次，试找出3条路径，使得取得的数总和最大。

【输入格式 Input Format】

第一行:N (4<=N<=20) 接下来一个N*N的矩阵，矩阵中每个元素不超过80，不小于0 【输出格式 Output Format】 一行，表示最大的总和。 【样例输入 Sample Input】 4 1 2 3 4 2 1 3 4 1 2 3 4 1 3 2 4 样例输出 Sample Output 39 注释 Hint 多进程DP 算法分析 可以用网络流来做 由于没做二取方格数；我一开始用一般DP；DP一次则把走过的路删去；3次DP； 只对了一组；看了题解后知道了我的算法虽然保证了3次DP的最优；但并不代表全局最优；是有反例的...... 其实可以用压缩数组的方法..因为每一阶段都只与上一阶段有关..滚动滚动数组..循环利用..不断再生..节约环保..{好像扯远了...-_-#}..不过节约时间起见..其实不用滚动数组也可以以0ms过掉.. 　　做这条题时很深刻地感受得到..这条题是斜着划分阶段的..太伟大了啦..而且由于每一阶段中..横坐标与纵坐标有一种莫名的内在关系..所以为数组节约了不少维..{不过就算不节约..N<=20..也应该不会超..}.. 用sum[k,x,y,z]表示当走到第K步时,且三人横坐标分别为X,Y,Z时..所取数的最大值..由于每一个人都可以由2个方向推来..所以一共有2^3=8种状态.. sum[k,x,y,x]=max(sum[k,x,y,z],sum[k-1,x+f[i,1],y+f[i,2],z+f[i,3]]) 且由于第K步只能到达横坐标<=min(k,n)的点..所以其实循环时可以节约节约.. 注意:每一格只能取一次..数组的大小.. 【代码】 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72

#include <stdio.h>
#include <string.h>
#define max(a,b) a>b?a:b
int min(int a, int b)
{
 
       if (a < b)
              return a;
       else
              return b;
 
}
 
int f[41][21][21][21], a[21][21];
 
int main()
{
 
       int n, i , j, k, x1, x2, x3, temp, s1, s2, s3;
       scanf("%d", &n);
 
       for (i = 1; i <= n; i++)
       {
              for (j = 1; j <= n; j++)
                     scanf("%d", &a[i][j]);
 
       }
 
       memset(f, 0, sizeof(f));
       f[1][1][1][1] = a[1][1];
 
       for (k = 2; k <= n + n -1; k++)
       {
              for (x1 = 1; x1 <= min(k, n); x1++)
              {
 
                     for (x2 = 1; x2 <= min(k, n); x2++)
                     {
                            for (x3 = 1; x3 <= min(k, n); x3++)
                            {
                                   temp = a[k - x1 + 1][x1] + a[k - x2 + 1][x2] + a[k - x3 + 1][x3];
 
                                   if (x1 == x2)
                                          temp -= a[k - x1 + 1][x1];
 
                                   if (x1 == x3)
                                          temp -= a[k - x1 + 1][x1];
 
                                   if (x2 == x3)
                                          temp -= a[k - x2 + 1][x2];
 
                                   if (x1 == x2 && x1 == x3)
                                          temp += a[k - x1 + 1][x1];
 
                                   for (s1 = -1; s1 <= 0; s1++)
                                   {
                                          for (s2 = -1; s2 <= 0; s2++)
                                          {
                                                 for (s3 = -1; s3 <= 0; s3++)
                                                 {
                                                        f[k][x1][x2][x3] = max(f[k][x1][x2][x3], f[k - 1][x1 + s1][x2 + s2][x3 + s3] + temp);
                                                 }
                                          }
                                   }
                            }
                     }
              }
       }
 
       printf("%d\n", f[n + n - 1][n][n][n]);
       return 0;
}
]]> https://www.phppan.com/2010/02/three-take-the-check-number/feed/ 0 小胖办证 https://www.phppan.com/2009/11/fatso-card-issuing-service/ https://www.phppan.com/2009/11/fatso-card-issuing-service/#comments Mon, 30 Nov 2009 11:29:15 +0000 http://www.phppan.com/?p=50 问题描述
【描述 Description 】

xuzhenyi要办个签证。办证处是一座M层的大楼，1<=M<=100。 每层楼都有N个办公室，编号为1..N(1<=N<=500)。每个办公室有一个签证员。 签证需要让第M层的某个签证员盖章才有效。 每个签证员都要满足下面三个条件之一才会给xuzhenyi盖章： 1. 这个签证员在1楼 2. xuzhenyi的签证已经给这个签证员的正楼下（房间号相同）的签证员盖过章了。 3. xuzhenyi的签证已经给这个签证员的相邻房间（房间号相差1，楼层相同）的签证员盖过章了。 每个签证员盖章都要收取一定费用，这个费用不超过1000000000。 找出费用最小的盖章路线，使签证生效 【输入格式 Input Format 】 第1行两个整数M和N。 接下来M行每行N个整数，第i行第j个数表示第i层的第j个签证员收取的费用。 【输出格式 Output Format】 按顺序打出你经过的房间的编号，每行一个数。 如果有多条费用最小的路线，输出任意一条。 【样例输入 Sample Input 】 3 4 10 10 1 10 2 2 2 10 1 10 10 10 【样例输出 Sample Output】 3 3 2 1 1 【算法分析】 DP顺序：从下到上，再从左到右，再从右到左 【代码】 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79

#include <stdio.h>
#include <string.h>
#define M 101
#define N 501
int a[M][N], x[M][N], y[M][N], f[M][N];
 
void print(int xx, int yy)
{
       if (xx < 1 || yy < 1)
              return ;
       print(x[xx][yy], y[xx][yy]);
       printf("%d\n", yy);
}
 
int main()
{
 
       int m, n, i, j, min, flag;
       scanf("%d%d", &m, &n);
 
       for (i = 1; i <= m; i++)
       {
              for (j = 1; j <= n; j++)
                     scanf("%d", &a[i][j]);
       }
 
       memset(x, 0, sizeof(x));
       memset(y, 0, sizeof(y));
       memset(f, 0, sizeof(f));
 
       for (j = 1; j <= n; j++)
       {
              f[1][j] = a[1][j];
       }
 
       for (i = 2; i <= m ; i++)
       {
              for (j = 1; j <= n; j++)
              {
                     f[i][j] = f[i - 1][j] + a[i][j];
                     x[i][j] = i - 1;
                     y[i][j] = j;
              }
 
              for (j = 2; j <= n; j++)
              {
                     if (a[i][j] + f[i][j - 1] < f[i][j])
                     {
                            f[i][j] = a[i][j] + f[i][j - 1];
                            x[i][j] = i;
                            y[i][j] = j - 1;
                     }     
              }
 
              for (j = n - 1; j >= 1; j--)
              {
                     if (a[i][j] + f[i][j + 1] < f[i][j])
                     {
                           f[i][j] = a[i][j] + f[i][j + 1];
                            x[i][j] = i;
                            y[i][j] = j + 1;
                     }
              }
       }
 
       min = 2000000000;
 
       for (i = 1; i <= n; i++)
       {
              if (f[m][i] < min)
              {
                     min = f[m][i];
                     flag = i;
              }
       }
 
       print(m, flag);
       return 0;
}
]]> https://www.phppan.com/2009/11/fatso-card-issuing-service/feed/ 0 数的划分 https://www.phppan.com/2009/11/entropy-of-a-partition/ https://www.phppan.com/2009/11/entropy-of-a-partition/#comments Fri, 20 Nov 2009 00:41:15 +0000 http://www.phppan.com/?p=54 问题描述
【描述 Description】
将整数n分成k份，且每份不能为空，任意两份不能相同(不考虑顺序)。
例如：n=7，k=3，下面三种分法被认为是相同的。
1,1,5; 1,5,1; 5,1,1;

问有多少种不同的分法。

【输入格式 Input Format】
输入n，k (6
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

#include <stdio.h>
 
int main()
{
 
       int a[201][10] = {0};
       int n, m, i, j;
 
       scanf("%d%d", &n, &m);
       a[0][0] = 1;
 
       for (i = 1; i <= n; i++)
       {
              for (j = 1; j <= m; j++)
                     if (i >= j )
                            a[i][j] = a[i - j][j] + a[i - 1][j - 1];                
       }
 
              printf("%d\n", a[n][m]);
       return 0;
}
]]> https://www.phppan.com/2009/11/entropy-of-a-partition/feed/ 0 4-Hanoi-Tower https://www.phppan.com/2009/10/4-hanoi-tower/ https://www.phppan.com/2009/10/4-hanoi-tower/#comments Thu, 15 Oct 2009 04:08:51 +0000 http://www.phppan.com/?p=61 问题描述
【描述 Description】
“汉诺塔”，是一个众所周知的古老游戏。现在我们把问题稍微改变一下：如果一共有4根柱子， 而不是3根，那么至少需要移动盘子多少次，才能把所有的盘子从第1根柱子移动到第4根柱子上呢？

为了编程方便，您只需要输出这个结果mod 10000的值。

【输入格式 Input Format】
一个正整数n。（0
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

#include <stdio.h>
int main()
{
       int n, m, s, t, i, j, flag;
       scanf("%d", &n);
 
       m = 1;
       s = 1;
       t = 2;
       flag = 0;
 
       for (i = 2; i <= n; i++)
       {
              if (flag == 1)
                     break;
 
              for (j = 1; j <= i; j++)
              {
                     s = (s + t) % 10000;
                     m++;
 
                     if (m == n)
                     {
                            printf("%d\n", s);
                            flag = 1;
                            break;
                     }
              }
              t = (t * 2) % 10000;
       }
       return 0;
}
]]> https://www.phppan.com/2009/10/4-hanoi-tower/feed/ 0 新年趣事之打牌 https://www.phppan.com/2009/10/new-years-cards/ https://www.phppan.com/2009/10/new-years-cards/#comments Tue, 13 Oct 2009 00:29:46 +0000 http://www.phppan.com/?p=64 问题描述
【描述 Description】
　　过年的时候，大人们最喜欢的活动，就是打牌了。xiaomengxian不会打牌，只好坐在一边看着。
　　这天，正当一群人打牌打得起劲的时候，突然有人喊道：“这副牌少了几张！”众人一数，果然是少了。于是这副牌的主人得意地说：“这是一幅特制的牌，我知道整副牌每一张的重量。只要我们称一下剩下的牌的总重量，就能知道少了哪些牌了。”大家都觉得这个办法不错，于是称出剩下的牌的总重量，开始计算少了哪些牌。由于数据量比较大，过了不久，大家都算得头晕了。
　　这时，xiaomengxian大声说：“你们看我的吧！”于是他拿出笔记本电脑，编出了一个程序，很快就把缺少的牌找了出来。
　　如果是你遇到了这样的情况呢？你能办到同样的事情吗？

【输入格式 Input Format】
　　第一行一个整数TotalW，表示剩下的牌的总重量。
　　第二行一个整数N（1
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63

#include <stdio.h>
#include <string.h>
 
#define MAXN 100001
int a[101], f[MAXN], last[MAXN], pre[MAXN];
 
void print(int s, int n)
{
       if (s != 0)
       {
              print(last[s], n);
              if (s == n)
                     printf("%d\n", pre[s]);
              else
                     printf("%d ", pre[s]);
       }
}
 
int main()
{
       int n, s, i, j, k;
 
       scanf("%d%d", &s, &n);
       for (i = 1; i <= n; i++)
       {
              scanf("%d", &a[i]);
              s = s - a[i];
       }
 
       s = -s;
       memset(f, 0, sizeof(f));
       memset(last, 0, sizeof(last));
       memset(pre, 0, sizeof(pre));
       f[0] = 1;
 
       for (i = 1; i <= n; i++)
       {
              for (j = s - a[i]; j >= 0; j--)
              {
                     if (f[j] > 0)
                     {
                            if (f[j + a[i]] == 0)
                            {
                                   f[j + a[i]] = f[j];
                                   last[j + a[i]] = j;
                                   pre[j + a[i]] = i;
                            }
                            else
                                   f[j + a[i]]++;
                     }
              }
       }
 
       if (f[s] == 0)
              printf("0\n");
       else if (f[s] > 1)
              printf("-1\n");
       else
       {
              print(s, s);
       }
       return 0;
}
]]> https://www.phppan.com/2009/10/new-years-cards/feed/ 0 迎春舞会之三人组舞 https://www.phppan.com/2009/10/spring-festival-dance/ https://www.phppan.com/2009/10/spring-festival-dance/#comments Fri, 09 Oct 2009 05:22:05 +0000 http://www.phppan.com/?p=67 【问题描述】
背景 Background
　　HNSDFZ的同学们为了庆祝春节，准备排练一场舞

【描述 Description】
　　n个人选出3*m人，排成m组，每组3人。
　　站的队形——较矮的2个人站两侧，最高的站中间。
　　从对称学角度来欣赏，左右两个人的身高越接近，则这一组的“残疾程度”越低。
　　计算公式为 h=(a-b)^2 (a、b为较矮的2人的身高)
　　那么问题来了。
　　现在候选人有n个人，要从他们当中选出3*m个人排舞蹈，要求总体的“残疾程度”最低。

【输入格式 Input Format】
　　第一排为m，n。
　　第二排n个数字，保证升序排列。

【输出格式 Output Format】
　　输出最小“残疾程度”。

【样例输入 Sample Input】
9 40
1 8 10 16 19 22 27 33 36 40 47 52 56 61 63 71 72 75 81 81 84 88 96 98 103 110 113 118 124 128 129 134 134 139 148 157 157 160 162 164

【样例输出 Sample Output】
23

注释 Hint
m<=1000,n<=5000 数据保证3*m<=n 【算法分析】 从大到小排序 a[i] f[i,j] 表示前i个数中有j对跳舞组合时的最优解 应为要最优就必须是排序时相邻两数的在两边才最好 而中间的人最高，记 f[i,j]=f[i-2,j-1]+(a[i]-a[i-1])^2 如果不取a[j]就 记 f[i,j]=f[i-1,j] 所以 f[i,j]=min{f[i,j]=f[i-2,j-1]+(a[i]-a[i-1])^2 | f[i,j]=f[i-1,j]} huyichen 摘自一大牛语录: 首先将筷子长度从短到长排序。 F[i,j,0]表示i个人使用前j双筷子，且第j根筷子不用，所需要长度差的平方和的最小值。 F[i,j,1]表示i个人使用前j双筷子，且使用第j根筷子，所需要长度差的平方和的最小值。 则F[i,j,0]=min{f[i,j-1,1]，f[i,j-1,0]}，F[i,j,1]=F[i-1,j-1,0]+(l[j]-l[j-1])^2 ans=min{F[k,n,1]，F[k,n,0]} 算法复杂度为O(NK)。 算法正确性的简单证明： 因为筷子配对的时候要求是长度平方差最小，所以每根筷子的配对的时候总是希望和长度差最小的配对，即排序后相邻两根筷子是可以配对的。l[a]，l，l[c]，l[d]表示4根排序好的筷子。因为(l-l[a])^2+(l[d]-l[c])^2<(l-l[c])^2+(l[d]-l[a])^2，所以上述配对方法是正确的。 本题同样可以把模型直接转变为二分图最小权匹配。 将两根筷子相连的边权值标记为两根筷子长度平方差，然后对二分图求一次最小权匹配。可以使用网络流的最小费用K流的算法，寻找K次最短路的增广轨。 算法复杂度为O(KN^3)。 非常显然，动态规划的复杂度远远低于二分图最小权匹配的复杂度。 【代码】 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39

#include <stdio.h>
#include <string.h>
 
int a[1001][5001];
int b[5001];
 
int main()
{
       int n, m, i, j, k, temp;
 
       scanf("%d%d", &m, &n);
       memset(b, 0, sizeof(b));
 
       for (i = 1; i <= n; i++)
              scanf("%d", &b[i]);
 
       for (i = 0; i <= m; i++)
       {
              for (j = 0; j <= n; j++)
                     a[i][j] = 2000000000;
       }
 
       for (i = 0; i <= n; i++)
              a[0][i] = 0;
 
       for (i = 1; i <= m; i++)
       {
              for (j = i + i; j <= n - (m - i) * 3; j++)
              {
                     a[i][j] = a[i][j - 1];
                     temp = a[i - 1][j - 2] + (b[j] - b[j - 1]) * (b[j] - b[j - 1]);
                     if ( j < n - (m - i) * 3 && temp < a[i][j])
                            a[i][j] = temp;
              }
       }
 
       printf("%d\n", a[m][n]);
       return 0;
}
]]> https://www.phppan.com/2009/10/spring-festival-dance/feed/ 0 迎春舞会之集体舞 https://www.phppan.com/2009/09/new-year-dance/ https://www.phppan.com/2009/09/new-year-dance/#comments Wed, 30 Sep 2009 04:17:13 +0000 http://www.phppan.com/?p=70 【问题描述】
背景 Background
　　HNSDFZ的同学们为了庆祝春节，准备排练一场舞会。
【描述 Description 】
　　表演者排成n排，构成一个向前的正三角形（在屏幕上,即向下）。而就每个人，他有可能正面朝前（小的向前正三角形）、或向后三角形（小的向后正三角形）。
　　然而这些人在服装上有明显区别——一部分穿冬季校服，其他的穿夏季校服。
　　现在给出每个人的着衣情况，请你求穿夏季校服的同学所构成的最大正三角形,输出所含人数。

输入格式 Input Format
　　第一排为n。
　　接下来n排，第i排有2*i-1个有效字符（‘#’或‘-’，分别表示此同学穿冬季校服或穿夏季校服）。输入文件中出现空格，且空格只是为了保持整个三角形的形状。

【输出格式 Output Format】
　　输出人数。

【样例输入 Sample Input】
5
#-##—-#
—–#-
—#-
-#-
-

样例输出 Sample Output
9

注释 Hint
n<=100 【算法分析】 对于三角形有两种情况： 尖向下时： f1[i][j]+=min(f1[i-1][j-1],f1[i-1][j],f1[i-1][j+1]) 尖向上时： f2[i][j]+=min(f2[i+1][j-1],f2[i+1][j],f2[i+1][j-1]) 而且一定要仔细看题目给的三角形 　　“他有可能正面朝前（小的向前正三角形）、或向后三角形（小的向后正三角形）” 注意几点： 1.尖向上的情况，只能是一行中的偶数个 2.尖向下的情况，只能是一行中的奇数个 代码 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80

#include <stdio.h>
#include <string.h>
 
#define min(a,b) a<b?a:b
 
int main()
{
       char ch[300][300];
       int f[300][300];
       int n, i, j, k, flag, max = 1, len;
 
       scanf("%d", &n);
       getchar();
 
       for (i = 0; i < n; i++)
       {
              gets(ch[i]);
       }
 
       memset(f, 0, sizeof(f));
       j = 0;
 
       while (ch[0][j] == ' ')
              j++;
 
       k = 1;
 
       while (j < strlen(ch[0]))
       {
              if (ch[0][j] == '#')
                     f[0][k++] = 0;
              else if (ch[0][j] == '-')
                     f[0][k++] = 1;
              j++;
       }
       for (i = 1; i < n; i++)
       {
              j = 0;
              while (ch[i][j] == ' ')
                     j++;
 
              k = i;
              flag = 0;
 
              while (ch[i][j] != '\0')
              {
                     if (ch[i][j] != ' ')
                     {
                            flag++;
                            k++;
 
                            if (ch[i][j] == '-')
                            {
                                   f[i][k] = 1;
                                   if (flag % 2 == 1)  //向下的三角形
                                   {
                                          if (f[i - 1][k] != 0 && f[i - 1][k - 1] != 0 && f[i - 1][k + 1] != 0)
                                          {
                                                 f[i][k] += min(f[i - 1][k - 1], f[i - 1][k + 1]);
                                          }
                                   }
                                   else  //向上的三角形
                                   {
                                          if (f[i][k - 1] != 0 && f[i][k - 2] != 0 && f[i - 1][k - 1] != 0)
                                          {
                                                 f[i][k] += min(f[i][k - 2], f[i - 1][k - 1]);
                                          }                                 
                                   }
 
                                   if (f[i][k] > max)
                                          max = f[i][k];
                            }
                     }
                     j++;
              }
       }
 
       printf("%d\n", max * (max * 2 -1 + 1) / 2);
       return 0;
}
]]> https://www.phppan.com/2009/09/new-year-dance/feed/ 0 棋盘制作 https://www.phppan.com/2009/09/boardproduction/ https://www.phppan.com/2009/09/boardproduction/#comments Thu, 24 Sep 2009 00:50:22 +0000 http://www.phppan.com/?p=72 【问题描述 】
国际象棋是世界上最古老的博弈游戏之一，和中国的围棋、象棋以及日本的将棋同享盛名。据说国际象棋起源于易经的思想，棋盘是一个8*8大小的黑白相间的方阵，对应八八六十四卦，黑白对应阴阳。

而我们的主人公小Q，正是国际象棋的狂热爱好者。作为一个顶尖高手，他已不满足于普通的棋盘与规则，于是他跟他的好朋友小W决定将棋盘扩大以适应他们的新规则。

小Q找到了一张由N*M个正方形的格子组成的矩形纸片，每个格子被涂有黑白两种颜色之一。小Q想在这种纸中裁减一部分作为新棋盘，当然，他希望这个棋盘尽可能的大。

不过小Q还没有决定是找一个正方形的棋盘还是一个矩形的棋盘（当然，不管哪种，棋盘必须都黑白相间，即相邻的格子不同色），所以他希望可以找到最大的正方形棋盘面积和最大的矩形棋盘面积，从而决定哪个更好一些。

于是小Q找到了即将参加全国信息学竞赛的你，你能帮助他么？

【输入格式 Input Format 】
第一行包含两个整数N和M，分别表示矩形纸片的长和宽。接下来的N行包含一个N * M的01矩阵，表示这张矩形纸片的颜色（0表示白色，1表示黑色）。

【输出格式 Output Format】
包含两行，每行包含一个整数。第一行为可以找到的最大正方形棋盘的面积，第二行为可以找到的最大矩形棋盘的面积（注意正方形和矩形是可以相交或者包含的）。

【样例输入 Sample Input】
3 3
1 0 1
0 1 0
1 0 0

【样例输出 Sample Output】
4
6

注释 Hint
对于20%的数据，N, M ≤ 80
对于40%的数据，N, M ≤ 400
对于100%的数据，N, M ≤ 2000

算法分析
和盖房子那道题目差不多吧.

正方形是一样的.只不过是重新开始的判断条件不同

长方形记录长和宽就好了.

【代码】

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125

#include <stdio.h>
#include <string.h>
#define MAXN 2001
int a[MAXN][MAXN], f[MAXN][MAXN], c[MAXN][MAXN], r[MAXN][MAXN];
 
int min(int t1, int t2)
{
        return t1<t2?t1:t2;
}
 
int main()
{
        int n, m, i, j, k, maxf = 0, maxc = 0, maxr = 0, s1, s2;
 
        scanf("%d%d", &n, &m);
 
        memset(f, 0, sizeof(f));
        memset(c, 0, sizeof(c));
 
        for (i = 1; i <= n; i++)
        {
               for (j = 1; j <= m; j++)
                      scanf("%d", &a[i][j]);
        }
 
        for (i = 1; i<= n; i++)
               f[i][1] = 1;     
 
        for (i = 1; i <= m; i++)
               f[1][i] = 1;
 
        for (i = 2; i <= n; i++)    //求正方形的连长
        {
               for (j = 2; j<= m; j++)
               {
                      if (a[i - 1][j] != a[i][j] && a[i][j - 1] != a[i][j])
                      {
                             f[i][j] = min(f[i - 1][j - 1], min(f[i - 1][j], f[i][j - 1])) + 1;
                      }
                      else
                      {
                             f[i][j] = 1;
                      }
 
                      if (f[i][j] > maxf)
                             maxf = f[i][j];
               }
        }
 
        c[1][1] = 1;    
        r[1][1] = 1;      //长宽初始化
 
        for (i = 2; i <= m; i++)
        {
               if (a[1][i] != a[1][i - 1])
               {
                      c[1][i] = c[1][i - 1] + 1;
               }
               else
                      c[1][i] = 1;
               r[1][i] = 1;
        }
 
        for (i = 2; i <= n; i++)
        {
               if (a[i][1] != a[i - 1][1])
               {
                      r[i][1] = r[i - 1][1] + 1;
               }
               else
                      r[i][1] = 1;
 
               c[i][1] = 1;
        }
 
        for (i = 2; i <= n; i++)
        {
               for (j = 2; j<= m; j++)
               {
                      if (a[i - 1][j] != a[i][j] && a[i][j - 1] != a[i][j])
                      {
                             s1 = min(c[i][j - 1] + 1, c[i - 1][j]) * (r[i - 1][j] + 1);
                             s2 = min(r[i - 1][j] + 1, r[i][j - 1]) * (c[i][j - 1] + 1);
 
                             if (s1 > s2)
                             {
                                    r[i][j] = r[i - 1][j] + 1;
                                    c[i][j] = min(c[i][j - 1] + 1, c[i - 1][j]);
                             }
                             else
                             {
                                    c[i][j] = c[i][j - 1] + 1;
                                    r[i][j] = min(r[i - 1][j] + 1, r[i][j - 1]);
                             }
                      }
                      else
                      {
                             if (a[i - 1][j] != a[i][j])
                             {
                                    r[i][j] = r[i - 1][j] + 1;
                                    c[i][j] = 1;
                             }
                             else if (a[i][j - 1] != a[i][j] )
                             {
                                    r[i][j] = 1;
                                    c[i][j] = c[i][j - 1] + 1;
                             }
                             else
                             {
                                    r[i][j] = 1;
                                    c[i][j] = 1;
                             }
                      }
 
                      if (r[i][j] * c[i][j] > maxr * maxc)
                      {
                             maxr = r[i][j];
                             maxc = c[i][j];
                      }
               }
        }
 
        printf("%d\n%d\n", maxf * maxf, maxr * maxc);
        return 0;
}
]]> https://www.phppan.com/2009/09/boardproduction/feed/ 0