P1117 数的划分


简单动归，搜一下就出来了，代码好短。

编译通过…
├ 测试数据 01：答案正确… 0ms
├ 测试数据 02：答案正确… 0ms
├ 测试数据 03：答案正确… 0ms
├ 测试数据 04：答案正确… 0ms
├ 测试数据 05：答案正确… 0ms
Accepted 有效得分：100 有效耗时：0ms

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
#include<stdio.h>

int N,K,Ans,Re[201][201][6];

int Search(int last,int num,int team)
{
    if(team==K)
    {
        if(num>=last)
            return 1;
        else
            return 0;
    }
    if(Re[last][num][team]==0)
    {
        int temp;
        for(temp=last;temp<=num;temp++)
            Re[last][num][team]+=Search(temp,num-temp,team+1);
    }
    return Re[last][num][team];
}

int main()
{
    scanf("%d %d",&N,&K);
    Ans=Search(1,N,1);
    printf("%d\n",Ans);
    return 0;
}

展开全文 >>

P1143 三取方格数


初赛虽然是挂了，还是得做题~

这是一个比较经典的题的改编，当时是只取两条路，有点类似于某年NOIP的传纸条游戏。在Vijos里改成了三条路，这就增加了一点难度，我原来是直接开四维数组DP，这里就开六维数组肯定爆。开始优化。

具体方法是只记录横坐标和步数，纵坐标用横坐标于步数来求。

数据在20内，很容易秒杀。O(∩_∩)O~

编译通过…
├ 测试数据 01：答案正确… 0ms
├ 测试数据 02：答案正确… 0ms
├ 测试数据 03：答案正确… 0ms
├ 测试数据 04：答案正确… 0ms
├ 测试数据 05：答案正确… 0ms
├ 测试数据 06：答案正确… 0ms
├ 测试数据 07：答案正确… 0ms
├ 测试数据 08：答案正确… 0ms
├ 测试数据 09：答案正确… 0ms
├ 测试数据 10：答案正确… 0ms
Accepted 有效得分：100 有效耗时：0ms 

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 N,Num[20][20],Re[21][21][21][41];

void Search(int xa,int xb,int xc,int step)
{
    if(Re[xa][xb][xc][step]==0)
    {
        int ya,yb,yc;
        ya=step-xa-1;
        yb=step-xb-1;
        yc=step-xc-1;
        if(xa<N&&xb<N&&xc<N&&ya<N&&yb<N&&yc<N)
        {
            Re[xa][xb][xc][step]+=Num[xa][ya];
            if(xb!=xa) Re[xa][xb][xc][step]+=Num[xb][yb];
            if(xc!=xa&&xc!=xb) Re[xa][xb][xc][step]+=Num[xc][yc];
            int temp=0;
            Search(xa+1,xb+1,xc+1,step+1);
            if(temp<Re[xa+1][xb+1][xc+1][step+1])
                temp=Re[xa+1][xb+1][xc+1][step+1];
            Search(xa+1,xb+1,xc,step+1);
            if(temp<Re[xa+1][xb+1][xc][step+1])
                temp=Re[xa+1][xb+1][xc][step+1];
            Search(xa+1,xb,xc+1,step+1);
            if(temp<Re[xa+1][xb][xc+1][step+1])
                temp=Re[xa+1][xb][xc+1][step+1];  
            Search(xa,xb+1,xc+1,step+1);
            if(temp<Re[xa][xb+1][xc+1][step+1])
                temp=Re[xa][xb+1][xc+1][step+1];
            Search(xa,xb,xc+1,step+1);
            if(temp<Re[xa][xb][xc+1][step+1])
                temp=Re[xa][xb][xc+1][step+1];
            Search(xa,xb+1,xc,step+1);
            if(temp<Re[xa][xb+1][xc][step+1])
                temp=Re[xa][xb+1][xc][step+1];
            Search(xa+1,xb,xc,step+1);
            if(temp<Re[xa+1][xb][xc][step+1])
                temp=Re[xa+1][xb][xc][step+1];  
            Search(xa,xb,xc,step+1);
            if(temp<Re[xa][xb][xc][step+1])
                temp=Re[xa][xb][xc][step+1];
            Re[xa][xb][xc][step]+=temp;
        }
    }
}

int main()
{
    int a,b;
    scanf("%d",&N);
    for(a=0;a<N;a++)
        for(b=0;b<N;b++)
            scanf("%d",&Num[a][b]);
    Search(0,0,0,1);
    printf("%d\n",Re[0][0][0][1]);
    return 0;
}

展开全文 >>

NOIP 2008 双栈排序


看网上正解写的，DFS染色后输出。可过让无数贪心程序挂掉的 5 7 2 4 1 6 3 这组数据。

编译通过…
├ 测试数据 01：答案正确… 0ms
├ 测试数据 02：答案正确… 0ms
├ 测试数据 03：答案正确… 0ms
├ 测试数据 04：答案正确… 0ms
├ 测试数据 05：答案正确… 0ms
├ 测试数据 06：答案正确… 0ms
├ 测试数据 07：答案正确… 0ms
├ 测试数据 08：答案正确… 0ms
├ 测试数据 09：答案正确… 41ms
├ 测试数据 10：答案正确… 197ms
Accepted 有效得分：100 有效耗时：238ms 

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
#include<stdio.h>
int N,Switch,In[1000],Color[1000],SPFA[1000][1000];
void DFS(int site,int color)
{
    int a,b;
    Color[site]=color;
    color=color>1?1:2;
    for(a=1;a<=SPFA[site][0];a++)
        if(Color[SPFA[site][a]]==0)
            DFS(SPFA[site][a],color);
        else if(Color[SPFA[site][a]]==Color[site])
            {Switch=0;break;}
}
void Pan()
{
    if(Switch<N)
    {
    if(SPFA[0][SPFA[0][0]]==Switch)
        {Switch++;SPFA[0][0]--;printf("b ");Pan();}
    else if(SPFA[1][SPFA[1][0]]==Switch)
        {Switch++;SPFA[1][0]--;printf("d ");Pan();}
    }
}
int main()
{
    scanf("%d",&N);
    int a,b,c;
    for(a=0;a<N;a++)
        {scanf("%d",&In[a]);In[a]--;}
    for(a=0;a<N;a++)
        for(b=a+1;b<N;b++)
            if(In>In[a])
                for(c=b+1;c<N;c++)
                    if(In[c]<In[a])
                    {
                        SPFA[In[a]][0]++;
                        SPFA[In[a]][SPFA[In[a]][0]]=In;
                        SPFA[In][0]++;
                        SPFA[In][SPFA[In][0]]=In[a];
                    }
    for(Switch=1,a=0;a<N&&Switch==1;a++)
        if(Color[a]==0)
            DFS(a,1);
    if(Switch==0)
        printf("0\n");
    else
    {
        Switch=0;
        memset(SPFA,0,sizeof(SPFA));
        //此处SPFA用来存 栈A 和 栈B。
        //SPFA[0][0] 栈A top;
        //SPFA[1][0] 栈B top;
        for(a=0;a<N;a++)
        {
        if(In[a]==Switch)
            {printf("a b ");Switch++;Pan();}
        else if(SPFA[0][0]==0)
            {SPFA[0][0]++;SPFA[0][SPFA[0][0]]=In[a];printf("a ");}
        else if(Color[SPFA[0][SPFA[0][0]]]!=Color[In[a]])
            {SPFA[1][0]++;SPFA[1][SPFA[1][0]]=In[a];printf("c ");}
        else
            {SPFA[0][0]++;SPFA[0][SPFA[0][0]]=In[a];printf("a ");}
        }
    }
    return 0;
}

展开全文 >>

NOIP 2007 矩阵取数游戏


一年以前看着道题，只会DP，不会用高精度。现在终于过了！！！！！！！！

编译通过…
├ 测试数据 01：答案正确… 0ms
├ 测试数据 02：答案正确… 0ms
├ 测试数据 03：答案正确… 0ms
├ 测试数据 04：答案正确… 0ms
├ 测试数据 05：答案正确… 0ms
├ 测试数据 06：答案正确… 0ms
├ 测试数据 07：答案正确… 41ms
├ 测试数据 08：答案正确… 447ms
├ 测试数据 09：答案正确… 603ms
├ 测试数据 10：答案正确… 0ms
Accepted 有效得分：100 有效耗时：1091ms

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
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
#include<stdio.h>

int N, M, Num[81][81], Re[81][81][50], Two[81][50], Ans[50];

void Search(int q, int h, int floor, int times) {
    if (q <= h && Re[q][h][49] == 0) {
        int a, b;
        int A[50] = {0}, B[50] = {0};

        //取前一个数的值赋给 A。 
        Search(q + 1, h, floor, times + 1);
        A[49] = Two[times][0] - 1;
        a = 0;
        b = 0;
        while (a <= A[49]) {
            A[a] = Num[floor][q] * Two[times][a + 1];
            A[a] += b;
            b = A[a] / 10000;
            A[a] %= 10000;
            while (a == A[49] && b != 0)
                A[49]++;
            a++;
        }
        if (A[49] < Re[q + 1][h][49])
            A[49] = Re[q + 1][h][49];
        a = 0;
        b = 0;
        while (a <= A[49]) {
            A[a] += Re[q + 1][h][a];
            A[a] += b;
            b = A[a] / 10000;
            A[a] %= 10000;
            while (a == A[49] && b != 0)
                A[49]++;
            a++;
        }

        //取前一个数的值赋给 B。
        Search(q, h - 1, floor, times + 1);
        B[49] = Two[times][0] - 1;
        a = 0;
        b = 0;
        while (a <= B[49]) {
            B[a] = Num[floor][h] * Two[times][a + 1];
            B[a] += b;
            b = B[a] / 10000;
            B[a] %= 10000;
            while (a == B[49] && b != 0)
                B[49]++;
            a++;
        }
        if (B[49] < Re[q][h - 1][49])
            B[49] = Re[q][h - 1][49];
        a = 0;
        b = 0;
        while (a <= B[49]) {
            B[a] += Re[q][h - 1][a];
            B[a] += b;
            b = B[a] / 10000;
            B[a] %= 10000;
            while (a == B[49] && b != 0)
                B[49]++;
            a++;
        }
        
        //取 A B 中最大的值给  Re[q][h];
        a = 0;
        if (A[49] > B[49])
            a = 1;
        else if (A[49] == B[49])
            for (b = A[49]; b >= 0; b--) {
                if (A[b] > B[b])
                    a = 1;
                else if (A[b] < B[b])
                    break;
            }
        if (a == 1) {
            Re[q][h][49] = A[49];
            for (b = 0; b <= A[49]; b++)
                Re[q][h][b] = A[b];
        } else {
            Re[q][h][49] = B[49];
            for (b = 0; b <= B[49]; b++)
                Re[q][h][b] = B[b];
        }
    }
}

int main() {
    scanf("%d %d", &N, &M);
    int a, b, c;
    for (a = 0; a < N; a++)
        for (b = 0; b < M; b++)
            scanf("%d", &Num[a][b]);

    //计算 2 的 M 次方。 
    Two[0][0] = 1;
    Two[0][1] = 1;
    for (a = 0; a < M; a++) {
        b = 1;
        c = 0;
        Two[a + 1][0] = Two[a][0];
        while (b <= Two[a + 1][0]) {
            Two[a + 1][b] = 2 * Two[a][b];
            Two[a + 1][b] += c;
            c = Two[a + 1][b] / 10000;
            Two[a + 1][b] %= 10000;
            if (c != 0 && b == Two[a + 1][0])
                Two[a + 1][0]++;
            b++;
        }
    }

    //高精度动态规划。
    for (a = 0; a < N; a++) {
        Search(0, M - 1, a, 1);
        Ans[49] = Ans[49] > Re[0][M - 1][49] ? Ans[49] : Re[0][M - 1][49];
        b = 0;
        c = 0;
        while (c <= Ans[49]) {
            Ans[c] += Re[0][M - 1][c];
            Ans[c] += b;
            b = Ans[c] / 10000;
            Ans[c] %= 10000;
            if (b != 0 && c == Ans[49])
                Ans[49]++;
            c++;
        }
        memset(Re, 0, sizeof(Re));
    }

    //高精度答案输出。 
    printf("%d", Ans[Ans[49]]);
    for (a = Ans[49] - 1; a >= 0; a--) {
        if (Ans[a] > 999)
            printf("%d", Ans[a]);
        else if (Ans[a] > 99)
            printf("0%d", Ans[a]);
        else if (Ans[a] > 9)
            printf("00%d", Ans[a]);
        else
            printf("000%d", Ans[a]);
    }
    return 0;
}

展开全文 >>

树形DP 将功补过


这几天做了一些树形DP的题，感觉不错！

将功补过（inform.pas/c/cpp）

【问题背景】

作为间谍专家的Elvis Han受窃取X星球军事中心的秘密情报，他已经成功进入军事中心。但是很不幸的是，在他还没有找到任务需要情报的时候就被发现，这时他清楚他不可能完成任务了，不过还有机会将功补过，也就是得到一些不如任务情报有价值的其他情报，如果得到的情报的总价值大于等于任务情报价值，他也不会受到惩罚。很幸运的是他已经得到的军事中心的地图，情报都是隐藏在各个道路上的，但是他只有时间遍历一定数量的路（时间宝贵呀！还要逃跑。。）现在你做为他的助手，给你地图和每个道路情报价值，希望你分析出，看他能不能将功补过。

【问题描述】

军事中心是一个严格的二叉树，也就是说，如果有个点可以分道，一定是分出，也只分出2条道路，现在Elvis Han正处在第一个分道处，也就是说树的根结点处。每条道路上都有一个分数，就是这个道路上的情报价值。但是他只有时间走M条路，他的最终情报价值总和就是他所经过的路的情报价值总和（假设他到过的路一定可以把所有情报得到）希望你给出一个方案使得他可以尽量多地获取情报以便将功补过。

【输入格式】

在输入文件inform.in中，共有N行：

第一行：3个数据：N，M，Q（N表示有多少个路口，包括分道和不分道的路口；M表示他可以有时间走的道路总数；Q表示他的任务情报的价值）

第2~N行：每行3个数据，Xi,Yi,Wi (X，Y表示第I条道路连接的2个路口，W表示这条道路上的情报价值分, 注意，所有数据均在Lonint范围内)

【输出格式】

在输出文件inform.out中，共包含2行：

第一行：输出TRUE/FALSE（注意大小写），表示他是否可以收集够任务情报价值

第二行：输出一个数据：

  • 如果他可以完成任务，就输出他收集的情报总价值超过任务情报价值的部分。（正数）

  • 如果不能完成任务，就输出一个数，表示他不能还差多少分才够任务情报价值。（负数）

【输入样例1】

3 1 10
1 2 10
1 3 8

【输出样例1】

TRUE
0

样例说明：(该部分不必输出)
3 2
（8）\ /（10）
1 （选择1条路当然选1-2）

【输入样例2】

9 3 49
6 2 15
7 2 10
8 7 6
7 9 15
1 3 20
2 1 10
4 3 8
3 5 7

【输出样例2】

FALSE
-4

样例说明：
8 9
(6) \ / (15)
6 7 4 5
（15）\ / （10）\ （8） /（7）
2 3
（10）\ /（20）
1(由于他最大可以取得的是[1->3]+[1->2]+[2->6]3条路径的价值，才45，所以不可能完成任务)

【数据规模】

  • 对于30%的数据 保证有N<=10
  • 对于50%的数据 保证有N<=40
  • 对于全部的数据保证有 N<=100

我的程序

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
#include<stdio.h>

FILE *fs, *fp;
long Max, N, M, Q, Map[101][101], Re[101][101];
struct {
    int fa;
    int lc;
    int rc;
} Tree[101];

void Make_tree(int site, int father) {
    int a;
    Tree[site].fa = father;
    for (a = 1; a <= N; a++)
        if (Map[site][a] != 0 && a != father) {
            Tree[site].lc = a;
            Make_tree(a, site);
            a++;
            break;
        }
    for (; a <= N; a++)
        if (Map[site][a] != 0 && a != father) {
            Tree[site].rc = a;
            Make_tree(a, site);
            a++;
            break;
        }
}

long Dp(int site, long time) {
    if (time == 0)
        return 0;
    else if (Re[site][time] != 0)
        return Re[site][time];
    else if (Tree[site].lc == 0 && Tree[site].rc == 0)
        return 0;
    else {
        long a, b;
        if (Tree[site].lc != 0) {
            a = Dp(Tree[site].lc, time - 1);
            a += Map[site][Tree[site].lc];
            Re[site][time] = a > Re[site][time] ? a : Re[site][time];
        }
        if (Tree[site].rc != 0) {
            a = Dp(Tree[site].rc, time - 1);
            a += Map[site][Tree[site].rc];
            Re[site][time] = a > Re[site][time] ? a : Re[site][time];
        }
        if (Tree[site].rc != 0 && Tree[site].lc != 0) {
            for (b = 0; b <= time - 2; b++) {
                a = Dp(Tree[site].lc, b);
                a += Map[site][Tree[site].lc];
                a += Dp(Tree[site].rc, time - 2 - b);
                a += Map[site][Tree[site].rc];
                Re[site][time] = a > Re[site][time] ? a : Re[site][time];
            }
        }
        return Re[site][time];
    }
}

int main() {
    fs = fopen("inform.in", "r");
    fp = fopen("inform.out", "w");
    fscanf(fs, "%ld %ld %ld", &N, &M, &Q);
    long a, b, c;
    for (a = 1; a < N; a++) {
        fscanf(fs, "%ld %ld", &b, &c);
        fscanf(fs, "%ld", &Map[c]);
        Map[c] = Map[c];
    }
    Make_tree(1, 0);
    Max = Dp(1, M);
    if (Max >= Q)
        fprintf(fp, "TRUE\n%ld\n", Max - Q);
    else
        fprintf(fp, "FALSE\n%ld\n", Max - Q);
    fclose(fs);
    fclose(fp);
    return 0;
}

展开全文 >>

P1484 ISBN号码 解题报告


题目不难，但是了解了许多关于ISBN的知识。

百度百科：http://bk.baidu.com/view/20171.html

编译通过…
├ 测试数据 01：答案正确… 0ms
├ 测试数据 02：答案正确… 0ms
├ 测试数据 03：答案正确… 0ms
├ 测试数据 04：答案正确… 0ms
├ 测试数据 05：答案正确… 0ms
├ 测试数据 06：答案正确… 0ms
├ 测试数据 07：答案正确… 0ms
├ 测试数据 08：答案正确… 0ms
├ 测试数据 09：答案正确… 0ms
├ 测试数据 10：答案正确… 0ms
Accepted 有效得分：100 有效耗时：0ms

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
#include<stdio.h>
int main()
{
    int ISBN[10],i,j;
    char temp;
    i=0;
    while(i<10)
    {
        temp=getchar();
        if(temp!='-')
            if(i<9)
                {ISBN=temp-'0';i++;}
            else
                {ISBN=temp;i++;}
    }
    for(i=0,j=0;i<=8;i++)
        j+=(i+1)*ISBN;
    j%=11;
    if(j==10) j='X';
    else j+='0';
    if(j==ISBN[9])
        printf("Right");
    else
        printf("%d-%d%d%d-%d%d%d%d%d-%c",
        ISBN[0],ISBN[1],ISBN[2],ISBN[3],ISBN[4],ISBN[5],ISBN[6],ISBN[7],ISBN[8],j);
    return 0;
}

展开全文 >>

P1258 多项式表示 解题报告


字符串处理的细节活。用了N个 if 。

编译通过…
├ 测试数据 01：答案正确… 0ms
├ 测试数据 02：答案正确… 0ms
├ 测试数据 03：答案正确… 0ms
├ 测试数据 04：答案正确… 0ms
├ 测试数据 05：答案正确… 0ms
├ 测试数据 06：答案正确… 0ms
├ 测试数据 07：答案正确… 0ms
├ 测试数据 08：答案正确… 0ms
├ 测试数据 09：答案正确… 0ms
├ 测试数据 10：答案正确… 0ms
Accepted 有效得分：100 有效耗时：0ms

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
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
#include<stdio.h>
int xiang[10],count,pan; 
void First(int a)
{
     if(a>1)
     {
         if(xiang[a]>0)
         {
             if(xiang[a]==1)
                 printf("x^%d",a);
             else
                 printf("%dx^%d",xiang[a],a);
             pan=1;
         }
         else if(xiang[a]<0)
         {
             if(xiang[a]==-1)
                 printf("-x^%d",a);
             else
                 printf("%dx^%d",xiang[a],a);  
             pan=1;
         }
         count--;
     }
     else
     {
         if(a==1)
         {
             if(xiang[a]>0)
             {
                 if(xiang[a]==1)
                     printf("x");
                 else
                     printf("%dx",xiang[a]);
                 pan=1;
             }
             else if(xiang[a]<0)
             {
                 if(xiang[a]==-1)
                     printf("-x");
                 else
                     printf("%dx",xiang[a]);  
                 pan=1;
             }
             count--;
         }
         else
         {
         printf("%d",xiang[a]);
         pan=1;
         count--;
         } 
     }
}
void Second(int a)
{
     if(a>1)
     {
         if(pan==1)
         {
             if(xiang[a]>0)
             {
                 if(xiang[a]==1)
                     printf(" + x^%d",a);
                 else
                     printf(" + %dx^%d",xiang[a],a);
             }
             else if(xiang[a]<0)
             {
                 if(xiang[a]==-1)
                     printf(" - x^%d",a);
                 else
                     printf(" - %dx^%d",-xiang[a],a);  
             }
             count--;
         }
         else
             First(a);
    }
    else
    {
        if(a==1)
        {
            if(pan==1)
             {
                 if(xiang[a]>0)
                 {
                     if(xiang[a]==1)
                         printf(" + x");
                     else
                         printf(" + %dx",xiang[a]);
                 }
                 else if(xiang[a]<0)
                 {
                     if(xiang[a]==-1)
                         printf(" - x",a);
                     else
                         printf(" - %dx",-xiang[a]);  
                 }
                 count--;
             }
             else
                 First(a);
        }
        else
        {
            if(pan==1)
             {
                 if(xiang[a]>0)
                 {
                     if(xiang[a]==1)
                         printf(" + 1");
                     else
                         printf(" + %d",xiang[a]);
                 }
                 else if(xiang[a]<0)
                 {
                     if(xiang[a]==-1)
                         printf(" - 1");
                     else
                         printf(" - %d",-xiang[a]);  
                 }
                 count--;
             }
             else
                 First(a);
        }
    }
}
int main()
{
    int i;
    for(i=8;i>=0;i--)
        scanf("%d",&xiang);
    pan=0;count=8;
    First(count);
    while(count>=0)
        Second(count); 
    return 0;
}

展开全文 >>

P1098 合唱队形 解题报告


类似最长不下降子序列。记录后DP一下就过了。

编译通过…
├ 测试数据 01：答案正确… 0ms
├ 测试数据 02：答案正确… 0ms
├ 测试数据 03：答案正确… 0ms
├ 测试数据 04：答案正确… 0ms
├ 测试数据 05：答案正确… 0ms
├ 测试数据 06：答案正确… 0ms
├ 测试数据 07：答案正确… 0ms
├ 测试数据 08：答案正确… 0ms
├ 测试数据 09：答案正确… 0ms
├ 测试数据 10：答案正确… 0ms
Accepted 有效得分：100 有效耗时：0ms

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
#include<stdio.h>
int N,people[100][4]; 
void Left(int a);
void Right(int a);
int Min(int a,int b);
int main()
    {
    scanf("%d",&N);
    memset(people,0,sizeof(people));
    int i,j;
    for(i=0;i<N;i++)
        scanf("%d",&people[0]);
    N--;
    people[0][1]=0;
    people[N][2]=0;
    for(i=1;i<=N;i++)
        Left(i);
    for(i=N-1;i>=0;i--)
        Right(i);
    for(i=1,j=people[0][1]+people[0][2];i<=N;i++)
        {
        people[3]=people[1]+people[2];
        if(j>people[3])
            j=people[3];
        }
    printf("%d",j);
    return 0;
    } 
int Min(int a,int b)
{
    if(a>b)
        a=b;
    return(a); 
}
void Left(int a)
{
     int i,j,k;
     for(i=0,j=a;i<a;i++)
         if(people[a][0]>people[0])
             {j=a-i-1+people[1];break;}
     for(i=0;i<a;i++)
         if(people[a][0]>people[0])
         {
             k=a-i-1+people[1];
             j=Min(j,k);
         }
     people[a][1]=j;
}
void Right(int a)
{
     int i,j,k;
     for(i=a+1,j=N-a;i<=N;i++)
         if(people[a][0]>people[0])
             {j=i-a-1+people[2];break;}
     for(i=a+1;i<=N;i++)
         if(people[a][0]>people[0])
         {
             k=i-a-1+people[2];
             j=Min(j,k);
         }
     people[a][2]=j;
}

展开全文 >>

P1398 奖学金 解题报告


题目简单，直接搜索过。

编译通过…
├ 测试数据 01：答案正确… 0ms
├ 测试数据 02：答案正确… 0ms
├ 测试数据 03：答案正确… 0ms
├ 测试数据 04：答案正确… 0ms
├ 测试数据 05：答案正确… 0ms
├ 测试数据 06：答案正确… 0ms
├ 测试数据 07：答案正确… 0ms
├ 测试数据 08：答案正确… 0ms
├ 测试数据 09：答案正确… 0ms
├ 测试数据 10：答案正确… 0ms
Accepted 有效得分：100 有效耗时：0ms

我的程序

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>
int num,score[300][4],count[300];
int Compare(int a,int b)
{
    if(score[count][1]<=score[count[a]][1])
        count=count[a];
    return b;
}
void Score()
{
     int max,i,j,k;
     for(max=0,i=0;i<num;i++)
         if(max<score[0])
             max=score[0];
     for(i=0,j=0;i<num;i++)
         if(max==score[0])
             {count[j]=i;j++;}
     if(j==1)
         {k=j;printf("%d %d\n",count[k-1]+1,score[count[k-1]][0]);}
     else
     {
         for(i=1;i<=j;i++)
             k=Compare(i-1,i);
         printf("%d %d\n",count[k-1]+1,score[count[k-1]][0]);
     }
     score[count[k-1]][0]=0;
}
int main()
{
    scanf("%d",&num);
    int i;
    for(i=0;i<num;i++)
        scanf("%d %d %d",&score[1],&score[2],&score[3]);
    for(i=0;i<num;i++)
        score[0]=score[1]+score[2]+score[3];
    for(i=0;i<5;i++)
        {memset(count,0,sizeof(count));Score();}
    return 0;
}

展开全文 >>

tag:

    缺失模块。
    1、请确保node版本大于6.2
    2、在博客根目录（注意不是yilia根目录）执行以下命令：
    npm i hexo-generator-json-content --save

    3、在根目录_config.yml里添加配置： 

      jsonContent:
    meta: false
    pages: false
    posts:
      title: true
      date: true
      path: true
      text: false
      raw: false
      content: false
      slug: false
      updated: false
      comments: false
      link: false
      permalink: false
      excerpt: false
      categories: false
      tags: true

一个人的命运啊，当然要靠自我奋斗，但是也要考虑到历史的行程。

很惭愧，就做了一点微小的工作，谢谢大家。