潘锦的空间 » DP https://www.phppan.com SaaS SaaS架构 团队管理 技术管理 技术架构 PHP 内核 扩展 项目管理 Sun, 10 May 2026 02:26:45 +0000 zh-CN hourly 1 https://wordpress.org/?v=3.9.40 最小矩阵和 https://www.phppan.com/2010/09/smallest-matrix-sum/ https://www.phppan.com/2010/09/smallest-matrix-sum/#comments Fri, 03 Sep 2010 01:03:38 +0000 http://www.phppan.com/?p=32 很久很久以前的代码，在某个角落找到，贴了上来，
在杭电acm1081上可以ac，来源应该是Greater New York 2001
貌似作为中南赛区ACM竞赛题

问题描述
【Description】

Given a two-dimensional array of positive and negative integers, a sub-rectangle is any contiguous sub-array of size 1*1 or greater located within the whole array. The sum of a rectangle is the sum of all the elements in that rectangle. In this problem the sub-rectangle with the largest sum is referred to as the maximal sub-rectangle.

As an example, the maximal sub-rectangle of the array:

0 -2 -7 0
9 2 -6 2
-4 1 -4 1
-1 8 0 -2

is in the lower left corner:

9 2
-4 1
-1 8
and has a sum of 15.

【Input】

The input consists of an N * N array of integers. The input begins with a single positive integer N on a line by itself, indicating the size of the square two-dimensional array. This is followed by N^2 integers separated by whitespace (spaces and newlines). These are the N^2 integers of the array, presented in row-major order. That is, all numbers in the first row, left to right, then all numbers in the second row, left to right, etc. N may be as large as 100. The numbers in the array will be in the range [-127,127].

【Output】

Output the sum of the maximal sub-rectangle.

【Sample Input】
4
0 -2 -7 0 9 2 -6 2
-4 1 -4 1 -1
8 0 -2

【Sample Output】
15

下面的中文来自：http://blog.csdn.net/hym666/archive/2010/08/17/5818591.aspx
此文章处有C++的解答

题目描述：
在一个大的方阵中找出一个子方阵，这个子方阵是所有子方阵和中的最大的一个
问题分析：
问题可以回归到一个数列中的连续字数列的和的最大值。
即把每一行看成一个数列。把每一列转换成一个数。
当然每一列也是一个数列，有很多的连续子数列。所有会有很多中情况。可穷举各种数列来构造一个行向的数列。
再用动态规划计算每一行的最大值，再在各行中选取最大的作为题目的解。

【代码】

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

import java.util.*;
 
public class Main {
 
       /**
        * @param args
        */
 
       public static int maxSum(int[] b, int n){
 
              int max = b[0], sum = 0;
 
              for (int i = 1; i < n ; i++ ){
                     if (max > 0)
                            max += b[i];
                     else
                            max = b[i];
 
                     if (max > sum)
                            sum = max;
              }
              return sum;
       }
 
       public static int maxTotal(int[][] a, int n){
 
              int max = 0;
              int[] b = new int[n];
 
              for (int i = 0; i < n; i++){
                     for (int j = 0; j < n; j++)
                            b[j] = a[i][j];
 
                     int sum = maxSum(b, n);
 
                     if (sum > max)
                            max = sum;
 
                     for (int j = i + 1; j < n; j++){
                            for (int k = 0; k < n; k++)
                                   b[k] += a[j][k];
 
                            sum = maxSum(b, n);
                            if (sum > max)
                                  max = sum;
                     }
              }
              return max;
       }
 
       public static void main(String[] args) {
              // TODO Auto-generated method stub
 
              Scanner cin = new Scanner(System.in);
              int n;
 
              while (cin.hasNext()){
                     n = cin.nextInt();
                     int[][] a = new int[n][n];
                     for (int i = 0; i < n; i++){
                            for (int j = 0; j < n; j++){
                                   a[i][j] = cin.nextInt();                                  
                            }
                     }
                     System.out.println(maxTotal(a, n));
              }
       }
}
]]> https://www.phppan.com/2010/09/smallest-matrix-sum/feed/ 0 垃圾陷阱 https://www.phppan.com/2010/06/trash-trap/ https://www.phppan.com/2010/06/trash-trap/#comments Wed, 30 Jun 2010 01:06:55 +0000 http://www.phppan.com/?p=34 问题描述
【Description】

卡门——农夫约翰极其珍视的一条Holsteins奶牛——已经落了到“垃圾井”中。“垃圾井”是农夫们扔垃圾的地方，它的深度为D (2 <= D <= 100)英尺。 卡门想把垃圾堆起来，等到堆得与井同样高时，她就能逃出井外了。另外，卡门可以通过吃一些垃圾来维持自己的生命。 每个垃圾都可以用来吃或堆放，并且堆放垃圾不用花费卡门的时间。 假设卡门预先知道了每个垃圾扔下的时间t(0a then a:=b。

　　这道题可以用DP解决。用l[i,j]表示掉下来i个垃圾后，卡门爬上的高度为j时她最长的寿命。显然l[0,0]=10。对于任一个状态l[i-1,j]，若l[i-1,j]>=g[i].time，说明这个状态的卡门能够坚持到下一个垃圾下落。在这种情况下，按以下两种方法处理第i个垃圾，即进行状态转移：

吃掉第i个垃圾，即update(l[i,j],l[i-1,j]+g[i].life)；

用第i个垃圾来垫高。令t=j+g[i].height，即把第i个垃圾用来垫高后卡门爬上的总高度。如果t>=d，则卡门于g[i].time时爬了出来，否则update(l[i,t],l[i-1,j])。

　　若首次遇到某一个l[i,0]一次也没有赋值，说明卡门不可能坚持到第i个垃圾下落，则她最多可以存活的时间为l[i-1,0]（即把前i-1个垃圾全吃掉后的寿命）。

　　注意到在计算l数组的第i行时只用到了第i-1行，因此l数组可用滚动数组来实现。

【代码】

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

#include <stdio.h>
#include <string.h>
 
#define MAXN 101
#define max(a,b) a>b?a:b
 
typedef struct node
{
       int time, life, height;
}node;
 
int main()
{
 
       node a[MAXN], temp;
       int flag;
 
       int f[MAXN][MAXN * 10];
       int n, d, i, j, k, t, maxt, m;
 
       scanf("%d%d", &d, &n);
       maxt = 0;
 
       for (i = 1; i <= n; i++)
       {
              scanf("%d%d%d", &a[i].time, &a[i].life, &a[i].height);
       }
 
       for (i = 1; i < n; i++)
       {
 
              for (j = i + 1; j <= n; j++)
              {
 
                     if (a[i].time > a[j].time)                                                                 
                     {
                            temp = a[i];
                            a[i] = a[j];
                            a[j] = temp;
 
                     }
              }
       }
 
       memset(f, 0, sizeof(f));
 
       f[0][0] = 10;
       flag = 0;
       maxt = 0;
 
       for (i = 1; i <= n; i++)
       {
 
              m = 0;
              k = 0;
 
              for (j = 0; j <= maxt; j++)
              {
 
                     if (f[i - 1][j] >= a[i].time)
                     {
 
                            f[i][j] = max(f[i][j], f[i - 1][j] + a[i].life);
                            t = j + a[i].height;
 
                            if (t >= d)
                            {
                                   flag = a[i].time;
                                   break;
                            }
 
                            if (t > m)
                                   m = t;
 
                            f[i][t] = max(f[i][t], f[i - 1][j]);
                            k++;
                     }
              }
 
              if (k == 0)
                     break;
 
              if (flag != 0)
                     break;
 
              maxt = m;
       }
 
       if (flag != 0)
              printf("%d\n", flag);
       else
       {
              printf("%d\n", f[i - 1][0]);
       }
       return 0;
}

应该是5年前的代码了，从以前的百度blog中转了过来

]]> https://www.phppan.com/2010/06/trash-trap/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 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 盖房子 https://www.phppan.com/2009/09/build-a-house/ https://www.phppan.com/2009/09/build-a-house/#comments Tue, 22 Sep 2009 00:52:31 +0000 http://www.phppan.com/?p=76 【问题描述】
永恒の灵魂最近得到了面积为n*m的一大块土地（高兴ING^_^），他想在这块土地上建造一所房子，这个房子必须是正方形的。
但是，这块土地并非十全十美，上面有很多不平坦的地方（也可以叫瑕疵）。这些瑕疵十分恶心，以至于根本不能在上面盖一砖一瓦。
他希望找到一块最大的正方形无瑕疵土地来盖房子。
不过，这并不是什么难题，永恒の灵魂在10分钟内就轻松解决了这个问题。
现在，您也来试试吧。

【输入格式 Input Format】
输入文件第一行为两个整数n,m（1<=n,m<=1000），接下来n行，每行m个数字，用空格隔开。0表示该块土地有瑕疵，1表示该块土地完好。 【输出格式 Output Format】 一个整数，最大正方形的边长。 【样例输入 Sample Input】 4 4 0 1 1 1 1 1 1 0 0 1 1 0 1 1 0 1 【样例输出 Sample Output 】 2 【算法分析】 状态方程就是.f[i,j]=min{f[i-1,j],f[i,j-1],f[i-1,j-1]}+1; f[i,j]表示的是 右下角坐标为(i,j)的正方形边长是f[i,j] 只要从左到右从上到下的2重循环就可以解决叻. 应该容易理解吧. 就贴一下Example Date运行后的F数组值 0 1 1 1 1 1 2 0 0 1 2 0 1 1 0 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

#include <stdio.h>
#include <string.h>
int a[1002][1002], f[1002][1002];
 
int main()
{
       int i, j, n, m, max = -1;
 
       scanf("%d%d", &n, &m);
       memset(a, 0, sizeof(a));
       memset(f, 0, sizeof(f));
 
       for (i = 1; i <= n; i++)
              for (j = 1; j <= m; j++)
                     scanf("%d", &a[i][j]);
 
              for (i = 1; i <= n; i++)
              {
                     for (j = 1; j <= n; j++)
                     {
                            if (a[i][j] == 1)
                            {
                                          f[i][j] = f[i - 1][j];
                                          if (f[i][j] > f[i][j - 1])
                                                 f[i][j] = f[i][j - 1];
 
                                          if (f[i][j] > f[i - 1][j - 1])
                                                 f[i][j] = f[i - 1][j - 1];
                                          f[i][j] = f[i][j] + 1;
                            }
                            else
                                   f[i][j] = a[i][j];
 
                            if (f[i][j] > max)
                                   max = f[i][j];
                     }
              }
 
              printf("%d\n", max);
              return 0;
}
]]> https://www.phppan.com/2009/09/build-a-house/feed/ 0 积木城堡　 https://www.phppan.com/2009/09/castle-blocks/ https://www.phppan.com/2009/09/castle-blocks/#comments Fri, 18 Sep 2009 14:57:19 +0000 http://www.phppan.com/?p=79 【问题描述】XC的儿子小XC最喜欢玩的游戏用积木垒漂亮的城堡。城堡是用一些立方体的积木垒成的，城堡的每一层是一块积木。小XC是一个比他爸爸XC还聪明的孩子，他发现垒城堡的时候，如果下面的积木比上面的积木大，那么城堡便不容易倒。所以他在垒城堡的时候总是遵循这样的规则。

小XC想把自己垒的城堡送给幼儿园里漂亮的女孩子们，这样可以增加他的好感度。为了公平起见，他决定把送给每个女孩子一样高的城堡，这样可以避免女孩子们为了获得更漂亮的城堡而引起争执。可是他发现自己在垒城堡的时候并没有预先考虑到这一点。所以他现在要改造城堡。由于他没有多余的积木了，他灵机一动，想出了一个巧妙的改造方案。他决定从每一个城堡中挪去一些积木，使得最终每座城堡都一样高。为了使他的城堡更雄伟，他觉得应该使最后的城堡都尽可能的高。

任务：

请你帮助小XC编一个程序，根据他垒的所有城堡的信息，决定应该移去哪些积木才能获得最佳的效果。

【输入格式 Input Format】
第一行是一个整数N(N<=100)，表示一共有几座城堡。以下N行每行是一系列非负整数，用一个空格分隔，按从下往上的顺序依次给出一座城堡中所有积木的棱长。用-1结束。一座城堡中的积木不超过100块，每块积木的棱长不超过100。

【输出格式 Output Format】
一个整数，表示最后城堡的最大可能的高度。如果找不到合适的方案，则输出0。

【样例输入 Sample Input】
2
2 1 –1
3 2 1 –1

【样例输出 Sample Output】
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
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

#include <stdio.h>
#include <stdlib.h>
 
int a[101][10001], b[101];
int main()
{
       int n, i, j, k, max, min, m, flag, pp;
 
       scanf("%d", &n);
       memset(a, 0, sizeof(a));
 
       min = 100001;
       for (k = 1; k <= n; k++)
       {
              b[0] = 0;
              scanf("%d", &m);
              while (m != -1)
              {
                     b[++b[0]] = m;
                     scanf("%d", &m);
              }
 
              a[k][0] = 1;
              max = 0;
 
              for (i = 1; i <= b[0]; i++)
              {
                     for (j = max; j >= 0; j--)
                     {
                            if (a[k][j] == 1 && j + b[i] <= min)
                            {
                                   a[k][j + b[i]] = 1;
                                   if (j + b[i] > max)
                                          max = j + b[i];
                            }
                     }
              }
 
              if (max > min)
                     min = max;
 
       }
 
       flag = -1;
       for (i = min; i > 0; i--)
       {
              for (k = 1; k <= n; k++)
                     if (a[k][i] == 0)
                            break;
 
                     if (k > n)
                     {
                            flag = k;
                            max = i;
                            break;
                     }
       }
 
       if (flag == -1)
              printf("0\n");
       else
              printf("%d\n", max);
 
       return 0;
}
]]> https://www.phppan.com/2009/09/castle-blocks/feed/ 0