7-1 序列调度 (100 分)
有一个N个数的序列A：1，2，……，N。有一个后进先出容器D，容器的容量为C。如果给出一个由1到N组成的序列，那么可否由A使用容器D的插入和删除操作得到。
输入格式:
第1行，2个整数T和C，空格分隔，分别表示询问的组数和容器的容量，1≤T≤10，1≤C≤N。
第2到T+1行，每行的第1个整数N，表示序列的元素数，1≤N≤10000。接下来N个整数，表示询问的序列。
输出格式:
T行。若第i组的序列能得到，第i行输出Yes；否则，第i行输出No,1≤i≤T。
输入样例:
在这里给出一组输入。例如：
2 2
5 1 2 5 4 3
4 1 3 2 4
输出样例:
在这里给出相应的输出。例如：
No
Yes思路
模拟栈
升序将中间内容全部入栈，并检查栈容量
降序则比较弹出元素是否与栈顶相同，否则即为非法弹出
代码
#include<iostream>
#include<cstdio>
#define fo(i,a,b) for(int i=(a);i<=(b);i++)
#define fw(i,a,b) for(int i=(a);i<(b);i++)
using namespace std;
const int inf=10050;
int a[inf];
int t,c,num;
int stac[inf];
int stapo=0;
int main()
{
int flag,count;
scanf("%d %d",&t,&c);
count=0;
fo(pp,1,t)
{
flag=0;
stapo=0;
scanf("%d",&num);
fo(i,1,num)
scanf("%d",a+i);
fo(i,0,num-1)
{
if(a[i]<a[i+1])
{
fo(j,a[i]+1,a[i+1]-1)
stac[stapo++]=j;
if(stapo+1>c)
{
flag=1;
break;
}
}
else
{
stapo--;
if(stac[stapo]!=a[i+1])
{
flag=1;
break;
}
}
}
if(flag)printf("No\n");
else printf("Yes\n");
}
return 0;
}7-2 最大最小差 (100 分)
对n 个正整数，进行如下操作：每一次删去其中两个数 a 和 b，然后加入一个新数：a*b+1，如此下去直到 只剩下一个数。所有按这种操作方式最后得到的数中，最大的为max，最小的为min，计算max-min。
输入格式:
第1行：n，数列元素的个数，1<=n<=16。
第2行：n 个用空格隔开的数x，x<=10。
输出格式:
1行，所求max-min。
输入样例:
在这里给出一组输入。例如：
3
2 4 3
输出样例:
在这里给出相应的输出。例如：
2思路
最大值类似哈夫曼树，每次取两个最小值加工后在入堆
最小值可不用堆，升序排好后，每次加工后的值放在末尾
代码
#include<iostream>
#include<cstdio>
#include<queue>
#define fo(i,a,b) for(int i=(a);i<=(b);i++)
#define fw(i,a,b) for(int i=(a);i<(b);i++)
using namespace std;
typedef long long ll;
priority_queue<ll,vector<ll>,greater<ll> >qsb;
priority_queue<ll,vector<ll> >qbs;
int main()
{
int n,t;
scanf("%d",&n);
for(int i=1;i<=n;i++)
{
scanf("%d",&t);
qsb.push(t);
qbs.push(t);
}
ll a,b;
for(int i=1;i<=n-1;i++)
{
a=qsb.top();
qsb.pop();
b=qsb.top();
qsb.pop();
qsb.push(a*b+1);
}
for(int i=1;i<=n-1;i++)
{
a=qbs.top();
qbs.pop();
b=qbs.top();
qbs.pop();
qbs.push(a*b+1);
}
printf("%lld",qsb.top()-qbs.top());
return 0;
}7-3 二叉树最短路径长度 (100 分)
给定一棵二叉树T，每个结点赋一个权值。计算从根结点到所有结点的最短路径长度。路径长度定义为：路径上的每个顶点的权值和。
输入格式:
第1行，1个整数n，表示二叉树T的结点数，结点编号1..n，1≤n≤20000。
第2行，n个整数，空格分隔，表示T的先根序列，序列中结点用编号表示。
第3行，n个整数，空格分隔，表示T的中根序列，序列中结点用编号表示。
第4行，n个整数Wi，空格分隔，表示T中结点的权值，-10000≤Wi≤10000，1≤i≤n。
输出格式:
1行，n个整数，表示根结点到其它所有结点的最短路径长度。
输入样例:
在这里给出一组输入。例如：
4
1 2 4 3
4 2 1 3
1 -1 2 3
输出样例:
在这里给出相应的输出。例如：
1 0 3 3思路
按先根方式建树，注意建立一个中根点编号与序列下标的映射加速查找。
每次递归取当前遍历到的先根序节点，在中根分划，然后在左右区域分别递归，注意返回条件。
边建树边深搜
代码
#include<iostream>
#include<cstdio>
#include<queue>
#include<algorithm>
#define fo(i,a,b) for(int i=(a);i<=(b);i++)
#define fw(i,a,b) for(int i=(a);i<(b);i++)
using namespace std;
const int inf=20050;
typedef long long ll;
int n;
struct Node
{
int left;
int right;
int val;
int lenth;
}node[inf];
int fg[inf];
int mg[inf];
int fgtot=0;
int loc[inf];
int make_tree(int from,int to,int length)
{
fgtot++;
int dq=fgtot;
int wz=loc[fg[dq]];
node[fg[dq]].lenth=length+node[fg[dq]].val;
if(from>=wz)node[fg[dq]].left=-1;
else node[fg[dq]].left=make_tree(from,wz,node[fg[dq]].lenth);
if(wz+1>=to)node[fg[dq]].right=-1;
else node[fg[dq]].right=make_tree(wz+1,to,node[fg[dq]].lenth);
return fg[dq];
}
int main()
{
scanf("%d",&n);
fo(i,1,n)
{
scanf("%d",fg+i);
}
fo(i,1,n)
{
scanf("%d",mg+i);
loc[mg[i]]=i;
}
fo(i,1,n)
scanf("%d",&(node[i].val));
make_tree(1,n+1,0);
fo(i,1,n)
{
if(i>1)printf(" ");
printf("%d",node[i].lenth);
}
return 0;
}7-4 方案计数 (100 分)
组装一个产品需要 n 个零件。生产每个零件都需花费一定的时间。零件的生产可以并行进行。有些零件的生产有先后关系，只有一个零件的之前的所有零件都生产完毕，才能开始生产这个零件。如何合理安排工序，才能在最少的时间内完成所有零件的生产。在保证最少时间情况下，关键方案有多少种，关键方案是指从生产开始时间到结束时间的一个零件生产序列，序列中相邻两个零件的关系属于事先给出的零件间先后关系的集合，序列中的每一个零件的生产都不能延期。
输入格式:
第1行，2个整数n和m，用空格分隔，分别表示零件数和关系数，零件编号1..n，1≤n≤10000, 0≤m≤100000 。
第2行，n个整数Ti，用空格分隔，表示零件i的生产时间，1≤i≤n，1≤Ti≤100 。
第3到m+2行，每行两个整数i和j，用空格分隔，表示零件i要在零件j之前生产。
输出格式:
第1行，1个整数，完成生产的最少时间。
第2行，1个整数，关键方案数，最多100位。
如果生产不能完成，只输出1行，包含1个整数0.
输入样例:
在这里给出一组输入。例如：
4 4
1 2 2 1
1 2
1 3
2 4
3 4
输出样例:
在这里给出相应的输出。例如：
4
2思路
典型关键路径题，只不过最后仅当存在关键路径时，将起点点权加到终点点权上去
注意高精度
代码
#include<iostream>
#include<queue>
#include<cstdio>
#include<cstring>
using namespace std;
queue<int>q;
const int inf=10005;
const int einf=10003;
int dps[inf];
int dpstot=0;
const int biws=120;
int maxx(int x,int y)
{
return x>y?x:y;
}
struct bigint
{
int fh;
int sw[biws];
int lenth;
bigint()
{
fh=0;
lenth=0;
memset(sw,0,sizeof(sw));
}
void bint(int x)
{
for(int i=x;i;i/=10)
{
sw[lenth]=i%10;
lenth++;
}
}
/* inline void input()
{
memset(sw,0,sizeof(sw));
fh=0;
lenth=0;
scanf("%s",s);
int len=strlen(s);
int fp=len-1;
for(;fp>=0;fp--)
{
if(*(s+fp)=='-')
fh=1;
else sw[lenth++]=*(s+fp)-'0';
}
}*/
void addoneself( bigint&x)
{
int len=maxx(lenth,x.lenth);
int fp;
if(fh!=x.fh)
{
if(bj(*this,x))
{
this->zjian(x);
}
else
{
fh=x.fh;
x.zjian(*this);
*this=x;
}
return;
}
for(lenth=0;lenth<len+3;lenth++)
{
sw[lenth]+=x.sw[lenth];
sw[lenth+1]+=sw[lenth]/10;
sw[lenth]%=10;
}
for(;sw[lenth-1]==0&&lenth>=1;lenth--)
;
}
void zjian(const bigint&y)
{
for(int i=0;i<y.lenth;i++)
{
sw[i]-=y.sw[i];
if(sw[i]<0)
{
sw[i+1]--;
sw[i]+=10;
}
}
for(;sw[lenth-1]==0&&lenth>=1;lenth--);
}
bool bj(const bigint&x,const bigint&y)
{
if(x.lenth!=y.lenth)
return x.lenth>y.lenth;
for(int i=x.lenth-1;i>=0;i--)
{
if(x.sw[i]!=y.sw[i])
return x.sw[i]>y.sw[i];
}
return 0;
}
void output()
{
if(lenth<=0)
{
printf("0");
return;
}
if(fh)printf("-");
for(int i=lenth-1;i>=0;i--)
{
printf("%d",sw[i]);
}
}
}num[inf];
struct hedge
{
int next;
int val;
int flag;
hedge(int n,int v){
next=n;
val=v;
flag=0;
}
void give(int n,int v)
{
next=n;
val=v;
}
void yes()
{
flag=1;
}
};
vector<hedge>edge[inf];
int n,m;
int wei[inf];
int early[inf];
int late[inf];
int rd[inf];
int cd[inf];
int main()
{
int x,y;
scanf("%d %d",&n,&m);
for(int i=1;i<=n;i++)
scanf("%d",wei+i);
hedge eg(0,0);
for(int i=1;i<=m;i++)
{
scanf("%d %d",&x,&y);
eg.give(y,wei[x]);
edge[x].push_back(eg);
rd[y]++;
cd[x]++;
}
int fl=0;
for(int i=1;i<=n;i++)
{
if(rd[i]||cd[i])
{
fl=1;
break;
}
}
if(!fl)
{
int maxf=0;
for(int i=1;i<=n;i++)
{
if(maxf<wei[i])maxf=wei[i];
}
int ftot=0;
for(int i=1;i<=n;i++)
{
if(maxf==wei[i])
{
ftot++;
}
}
printf("%d\n%d",maxf,ftot);
return 0;
}
for(int i=1;i<=n;i++)
{
if(!rd[i])
{
eg.give(i,0);
edge[0].push_back(eg);
rd[i]++;
cd[0]++;
}
if(!cd[i])
{
eg.give(einf,wei[i]);
edge[i].push_back(eg);
rd[einf]++;
cd[i]++;
}
}
memset(late,-1,sizeof(late));
memset(early,0,sizeof(early));
q.push(0);
late[0]=0;
int tmp;
int flag=0;
while(!q.empty())
{
tmp=q.front();
q.pop();
dps[dpstot++]=tmp;
//late[tmp]=1;
for(vector<hedge>::iterator it=edge[tmp].begin();it!=edge[tmp].end();it++)
{
if(late[it->next]<0)
{
rd[it->next]--;
if(early[tmp]+it->val>early[it->next])
early[it->next]=early[tmp]+it->val;
if(rd[it->next]<=0)
{
late[it->next]=0;
q.push(it->next);
}
}
/*else
{
flag=1;
break;
}*/
}
//if(flag)break;
}
for(int i=1;i<=n;i++)
{
if(rd[i]>0)
{
printf("0");
return 0;
}
}
for(int i=0;i<inf;i++)
{
late[i]=inf*inf;
}
if(einf==dps[dpstot-1])
{
late[einf]=early[einf];
}
for(int i=dpstot-2;i>=0;i--)
{
tmp=dps[i];
for(vector<hedge>::iterator it=edge[tmp].begin();it!=edge[tmp].end();it++)
{
if(late[it->next]-it->val<late[tmp])
{
late[tmp]=late[it->next]-it->val;
}
/*else
{
flag=1;
break;
}*/
}
}
num[0].bint(1);
for(int i=0;i<=dpstot-2;i++)
{
tmp=dps[i];
for(vector<hedge>::iterator it=edge[tmp].begin();it!=edge[tmp].end();it++)
{
if(early[tmp]==late[it->next]-it->val)
{
num[it->next].addoneself(num[tmp]);
}
/*else
{
flag=1;
break;
}*/
}
}
printf("%d\n",early[dps[dpstot-1]]);
num[dps[dpstot-1]].output();
printf("\n");
return 0;
}
扫一扫
1990
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
