第七届河南省赛 题解&&题型分布

第七届省赛我还在高三，所以没有机会参加，qaq

整体来说：我会的：A 简单搜索（背包也行吧） B跟POj2253查不到 最短路（很多都是并查集写的，不知道为啥） D 动态规划（算裸的吧） F 很水的模拟 H 贪心加简单的排序 G同POJ2567也算是简单的模拟

A：

10401: A.物资调度

Time Limit: 2 Sec   Memory Limit: 128 MB
Submit: 103   Solved: 59
[ Submit][ Status][ Web Board]

Description

某地区发生了地震，灾区已经非常困难，灾民急需一些帐篷、衣物、食品和血浆等物资。可通往灾区的道路到处都是塌方，70%以上的路面损坏，桥梁全部被毁。国家立即启动应急预案，展开史上最大强度非作战空运行动，准备向灾区空投急需物资。

一方有难，八方支援。现在已知有N个地方分别有A1，A2,….,An个物资可供调配。目前灾区需要物资数量为M。

现在，请你帮忙算一算，总共有多少种物质调度方案。

假设某地方一旦被选择调配，则其物资数全部运走。

Input

第一行： K     表示有多少组测试数据。

接下来对每组测试数据有2行，第1行:  N  M

                            第2行：A1  A2 ……  An

2≤K≤8     1<N≤100   1<M≤1000     1≤ Ai≤1000 

所有数据都是正整数。输入数据之间有一个空格。

假设给定的数据至少有一种调度方案。

Output

对于每组测试数据，输出一行：物资调度的总方案数

Sample Input

24 41 1 2 24 61 1 2 2

Sample Output

31

HINT

Source

简单的搜索吧，背包也行？背包不太会玩。。就简单搜下吧

#include<stdio.h>
#include<string.h>
#define MOD  100000007
#include <cstdio>
#include <cstring>
#include <stack>
#include <queue>
#include <map>
#include <set>
#include <vector>
#include <cmath>
#include <algorithm>
using namespace std;
int n,m;
int ans;
int vis[105];
int a[105];
void  dfs(int s,int sum)
{
    if(m==sum)
    {
        ans++;
        return;
    }
    if(sum>m)
        return ;
    for(int i=s; i<n; i++)
    {
        if(sum+a[i]<=m&&!vis[i])
        {
            vis[i]=1;
            dfs(i+1,sum+a[i]);
            vis[i]=0;
        }
    }
}
int main()
{
    int test;
    scanf("%d",&test);
    while(test--)
    {
        scanf("%d%d",&n,&m);
        memset(vis,0,sizeof(vis));
        for(int i=0; i<n; i++)
            scanf("%d",&a[i]);
        ans=0;
        sort(a,a+n);
        dfs(0,0);
        printf("%d\n",ans);
    }
}

B：

10400: B.海岛争霸

Time Limit: 2 Sec   Memory Limit: 128 MB
Submit: 137   Solved: 53
[ Submit][ Status][ Web Board]

Description

神秘的海洋，惊险的探险之路，打捞海底宝藏，激烈的海战，海盗劫富等等。加勒比海盗，你知道吧？杰克船长驾驶着自己的的战船黑珍珠1号要征服各个海岛的海盜，最后成为海盗王。 这是一个由海洋、岛屿和海盗组成的危险世界。杰克船长准备从自己所占领的岛屿A开始征程，逐个去占领每一个岛屿。面对危险重重的海洋与诡谲的对手，如何凭借智慧与运气，建立起一个强大的海盗帝国。

杰克船长手头有一张整个海域的海图，上面详细地记录了各个海屿的位置，以及海屿之间的通航路线。但他发现，有的航海路线太危险了，杰克船长的战船很难直接通过，他必须想方设法绕道航行；还有的岛屿根本到达不了。

杰克船长现在想把航行的危险程度降到最小。具体地来说，就是杰克船长提出若干个询问，他想知道从岛屿A 到岛屿B 有没有行驶航线，若有的话，所经过的航线，危险程度最小可能是多少。

Input

第1行:     N M        表示有N个岛屿，M条直航路线

第2~M+1行：    A   B   V   表示从岛屿A到岛屿B的航海路线的危险程度值为V。

接下面一行 ：    Q           表示询问的次数。

之后有Q个行：  A B       表示询问从岛屿A 到岛屿B 所经过的航线，危险程度最小值

 1<N≤100  0<M ≤ 500   1≤ Q≤20    0 < V≤ 1000 ，

所有数据都是正整数。输入数据之间有一个空格。

 

Output

对于每个询问，输出占一行，一个整数，表示从岛屿A 到岛屿B 所经过的航线，危险程度最小值；若从岛屿A 无法到达岛屿B，则输出-1。

Sample Input

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

Sample Output

5
5
-1
5
-1

HINT

Source

POJ2253差不多，就是迪杰斯塔拉的变形，我最短路分组里有，套套模板就能过，但是很多人都是用并查集写的，感觉也很不错，就是暴力，通过往一个空树上面加边，知道出现要求的2个联通，数据小就是可以这么任性暴力

贴一个迪杰斯特拉的

#include <iostream>
#include <cstdio>
#include <cstring>
using namespace std;
const int maxn = 220;
#define INF 0x3f3f3f3f
int n;
int G[maxn][maxn], d[maxn];
void  suan(int s)
{
    bool vis[maxn];
    memset(vis, false, sizeof(vis));
    for(int i=0; i<=n; i++)
    {
        d[i] = G[s][i];
    }
    d[s] = 0;
    vis[s] = true;
    for(int i=0; i<=n-1; i++)
    {
        int m = INF;
        int x;
        for(int y=0; y<=n; y++)
        if(!vis[y] && m >= d[y] )
        {
            x=y;
            m = d[y];
        }
        ///  X记录
        vis[x] = true;
        for(int y=0; y<=n; y++)
        {
            if(!vis[y])
            {
                int maxx= max(d[x], G[x][y]);
                if(d[y] > maxx) d[y] = maxx;
            }
        }
    }
}
int main()
{
    int m;
    while(~scanf("%d%d", &n,&m))
    {
        for(int i=0; i<=n; i++)
        {
            for(int j=0; j<=n; j++)
            {
                if(i==j) G[i][j]=0;
                else G[i][j] = G[j][i] =INF;
            }
        }
        int a,b,c;
        for(int i=1; i<=m; i++)
        {
            scanf("%d%d%d",&a,&b,&c);
            if(G[a][b]>c)
            G[a][b]=G[b][a]=c;
        }
        int q;
        scanf("%d",&q);
        while(q--)
        {
            int s,t;
            scanf("%d%d",&s,&t);
            suan(s);
            if(d[t]==INF)
                printf("-1\n");
            else printf("%d\n",d[t]);
        }
    }
}

C 扩展欧几里得的用法，表示看半天也看不懂，我菜怪我喽

D 

10403: D.山区修路

Time Limit: 2 Sec   Memory Limit: 128 MB
Submit: 81   Solved: 27
[ Submit][ Status][ Web Board]

Description

某山区的孩子们上学必须经过一条凹凸不平的土路，每当下雨天，孩子们非常艰难。现在村里走出来的Dr. Kong决定募捐资金重新修建着条路。由于资金有限，为了降低成本，对修好后的路面高度只能做到单调上升或单调下降。

为了便于修路，我们将整个土路分成了N段，每段路面的高度分别A1，A2,….,An。由于将每一段路垫高或挖低一个单位的花费成本相同，修路的总费用与路面的高低成正比。

现在Dr. Kong希望找到一个恰好含N个元素的不上升或不下降序列B1，B2,….,Bn，作为修过的路路段的高度。要求：

 

         | A1-B1| + | A2–B2| + ... + | An-Bn|------>最小

Input

第一行： K                            表示有多少组测试数据。

接下来对每组测试数据：

第1行:       N                表示整个土路分成了N段

第2~N+1行： A1  A2 ……AN     表示每段路面的高度

2≤k≤10      0≤Ai≤107     0≤N≤500    (i=1,…, N)

所有数据都是整数。 数据之间有一个空格。

数据保证| A1-B1|+| A2-B2|+ ... +| An-Bn|的最小值不会超过109

Output

对于每组测试数据，输出占一行：| A1-B1|+| A2-B2|+ ... +| An-Bn|的最小值。

Sample Input

271 3 2 4 5 3 958 6 5 6 2

Sample Output

31

简单dp dp[i][j]表示第i个元素改变为第j个的最小话费

dp[i][j]=abs(a[i],b[j])+temp(1到j的最小花费)

tip：思路别人的，本人dp渣渣

代码：

#include <iostream>
#include <cstdio>
#include <cstring>
#include<algorithm>
#include<math.h>
using namespace std;
#define INF 0x3f3f3f3f
int a[600];
int b[600];
int dp[600][600];
bool cmp(int a,int b)
{
    return a>b;
}
int main()
{
    int test;
    scanf("%d",&test);
    while(test--)
    {
        int n,temp;
        scanf("%d",&n);
        memset(a,0,sizeof(a));
        memset(b,0,sizeof(b));
        memset(dp,0,sizeof(dp));
        for(int i=1; i<=n; i++)
        {
            scanf("%d",&a[i]);
            b[i]=a[i];
        }
        sort(a+1,a+1+n);
 
        for(int i=1; i<=n; i++)
        {
 
 
            temp=INF;
            for(int j=1; j<=n; j++)
            {
 
                dp[i][j]=abs(b[i]-a[j]);
                temp=min(temp,dp[i-1][j]);
                if(temp!=INF)
                    dp[i][j]+=temp;
            }
 
        }
        int sum1=INF;
        for(int i=1; i<=n; i++)
            sum1=min(sum1,dp[n][i]);
        sort(a+1,a+1+n,cmp);
        for(int i=1; i<=n; i++)
        {
            temp=INF;
            for(int j=1; j<=n; j++)
            {
                 dp[i][j]=abs(b[i]-a[j]);
                temp=min(temp,dp[i-1][j]);
                if(temp!=INF)
                    dp[i][j]+=temp;
            }
 
        }
        int sum2=INF;
        for(int i=1; i<=n; i++)
            sum2=min(sum2,dp[n][i]);
        printf("%d\n",min(sum1,sum2));
    }
}
 

E 没看懂

F 纯模拟

#include<stdio.h>
#include<string.h>
#define MOD  100000007
#include <cstdio>
#include <cstring>
#include <stack>
#include <queue>
#include <map>
#include <set>
#include <vector>
#include <cmath>
#include <algorithm>
using namespace std;
char a[105];
char aa[10];
char bb[10];
char cc[10];
int main()
{
    while(gets(a))
    {
        if(strlen(a)==5&&a[0]=='0'&&a[1]=='+'&&a[2]=='0'&&a[3]=='='&&a[4]=='0')
            break;
        memset(aa,0,sizeof(aa));
        memset(bb,0,sizeof(bb));
        memset(cc,0,sizeof(cc));
        int la=strlen(a);
        int counta=0;
        int countb=0;
        int countc=0;
        int i,j,k;
        for( i=0; i<la&&a[i]!='+'; i++)
        {
            aa[counta++]=a[i];
        }
        for( j=i+1; j<la&&a[j]!='='; j++)
 
        {
            bb[countb++]=a[j];
        }
        for(k=j+1; k<la; k++)
        {
            cc[countc++]=a[k];
        }
        int aaa=0;
        int bbb=0;
        int ccc=0;
 
        for(i=counta-1; i>=0; i--)
            aaa=aaa*10+aa[i]-'0';
        for(i=countb-1; i>=0; i--)
            bbb=bbb*10+bb[i]-'0';
        for(i=countc-1; i>=0; i--)
            ccc=ccc*10+cc[i]-'0';
      if(aaa+bbb==ccc)
        printf("TRUE\n");
      else printf("FALSE\n");
    }
}

G同POJ2567，百科上给出的求解很明白

将树转化成Prufer数列的方法

一种生成Prufer序列的方法是迭代删点，直到原图仅剩两个点。对于一棵顶点已经经过编号的树T，顶点的编号为{1,2,...,n}，在第i步时，移去所有叶子节点（度为1的顶点）中标号最小的顶点和相连的边，并把与它相邻的点的编号加入Prufer序列中，重复以上步骤直到原图仅剩2个顶点。

例子

Prufer数列

以右边的树为例子，首先在所有叶子节点中编号最小的点是2，和它相邻的点的编号是3，将3加入序列并删除编号为2的点。接下来删除的点是4，5被加入序列，然后删除5，1被加入序列，1被删除，3被加入序列，此时原图仅剩两个点（即3和6），Prufer序列构建完成，为{3,5,1,3

将Prufer数列转化成树的方法

设{a1,a2,..an-2}为一棵有n个节点的树的Prufer序列，另建一个集合G含有元素{1..n}，找出集合中最小的未在Prufer序列中出现过的数，将该点与Prufer序列中首项连一条边，并将该点和Prufer序列首项删除，重复操作n-2次，将集合中剩余的两个点之间连边即可。

例子

仍为上面的树，Prufer序列为{3,5,1,3}，开始时G={1,2,3,4,5,6}，未出现的编号最小的点是2，将2和3连边，并删去Prufer序列首项和G中的2。接下来连的边为{4,5},{1,5},{1,3},此时集合G中仅剩3和6，在3和6之间连边，原树恢复。

#include<stdio.h>
#include<string.h>
#include<stdlib.h>
#include<stdlib.h>
  
char a[10005];
int map[55][55];
int du[55];
int n,now;
int la;
int build(char *a)
{
    int num=-1;
    while(now<la)
    {
        if(a[now]>='0'&&a[now]<='9')
        {
            if(a[now+1]>='0'&&a[now+1]<='9')
            {
                num=(a[now]-'0')*10+a[now+1]-'0';
                now+=2;
            }
            else
  
            {
                num=a[now]-'0';
                now++;
            }
            if(n<num)
                n=num;
            continue;
        }
        if(a[now]=='(')
        {
            now++;
            int temp=build(a);
            du[temp]++;
            du[num]++;
            map[temp][num]=1;
            map[num][temp]=1;
        }
        else if(a[now]==')')
        {
            now++;
            return num;
        }
        else if(a[now]==' ')
        {
            now++;
            continue;
        }
    }
}
int main()
{
    memset(a,0,sizeof(a));
    while(gets(a))
    {
        la=strlen(a);
        now=1;
        n=-2;
        memset(du,0,sizeof(du));
        memset(map,0,sizeof(map));
        build(a);
        int sb=0;
        for(int i=1; i<=n-1; i++)
        {
            for(int j=1; j<=n; j++)
            {
                if(du[j]==1)
                {
                    du[j]--;
                    for(int k=1; k<=n; k++)
                    {
                        if(map[j][k]==1)
                        {
                            map[j][k]=0;
                            map[k][j]=0;
                            du[k]--;
  
                            if(sb==0)
                                printf("%d",k);
                            else    printf(" %d",k);
                            sb++;
                            break;
                        }
                    }
                    break;
                }
            }
        }
        printf("\n");
  
    }
}

H 排序加上简单dp，还要注意长宽的选择（输入不一定）

#include<stdio.h>
#include<string.h>
#define MOD  100000007
#include <cstdio>
#include <cstring>
#include <stack>
#include <queue>
#include <map>
#include <set>
#include <vector>
#include <cmath>
#include <algorithm>
using namespace std;
typedef struct
{
    int lenth;
    int width;
} node;
node q[1105];
int dp[1300];
bool cmp(node a,node b)
{
    if(a.lenth==b.lenth)
        return a.width<b.width;
    return a.lenth<b.lenth;
}
int main()
{
    int test;
    scanf("%d",&test);
    while(test--)
    {
        int count=0;
        int n;
        scanf("%d",&n);
        for(int i=0; i<n; i++)
        {
            int a,b;
            scanf("%d%d",&a,&b);
            if(a>b)
            {
                q[count].lenth=a;
                q[count].width=b;
                count++;
            }
            else
            {
                q[count].lenth=b;
                q[count].width=a;
                count++;
            }
        }
        sort(q,q+count,cmp);
        for(int i=0; i<n; i++)
            dp[i]=1;
        for(int i=0; i<n; i++)
        {
            for(int j=0; j<i; j++)
            {
 
 
                if(dp[i]<dp[j]+1&&q[i].lenth>=q[j].lenth&&q[i].width>=q[j].width)
                    if(q[i].lenth!=q[j].lenth||q[j].width!=q[i].width)
                    {
                        dp[i]=dp[j]+1;
                    }
 
 
 
            }
        }
        sort(dp,dp+n);
        printf("%d\n",dp[n-1]);
    }
}
 

I  没看