第七届省赛我还在高三,所以没有机会参加,qaq
整体来说:我会的:A 简单搜索(背包也行吧) B跟POj2253查不到 最短路(很多都是并查集写的,不知道为啥) D 动态规划(算裸的吧) F 很水的模拟 H 贪心加简单的排序 G同POJ2567也算是简单的模拟
A:
10401: A.物资调度
Time Limit: 2 Sec Memory Limit: 128 MBSubmit: 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 MBSubmit: 137 Solved: 53
[ Submit][ Status][ Web Board]
Description
Input
Output
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 扩展欧几里得的用法,表示看半天也看不懂,我菜怪我喽
10403: D.山区修路
Time Limit: 2 Sec Memory Limit: 128 MBSubmit: 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个的最小话费
#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 没看懂
#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数列转化成树的方法
#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 没看