这次上机的题目考查的内容以图论的一些基础算法为主，我实话实话这次上机题有出失误的地方，个别题的难度没有控制好，所以过题情况不佳也是情理之中。
A. 对称二叉树
与上一次上机的同构二叉树很相似，这不过这道题要求的是轴对称；事实上也只要在那道题的基础上改动几处代码就可以了。
#include<cstdio>
#include<cstdlib>
#include<cstring>
using namespace std;
const int MAXN=1005;
struct BTNode
{
char data[10];
BTNode *lchild,*rchild;
};
char str[MAXN];
void CreateBTNode(BTNode *&b)
{
BTNode *St[MAXN],*p;
int top=-1,k,l=strlen(str);
b=NULL;
for(int i=0; i<l; ++i)
switch(str[i])
{
case '(':
St[++top]=p;
k=1;
break;
case ')':
--top;
break;
case ',':
k=2;
break;
default:
p=(BTNode *)malloc(sizeof(BTNode));
int j=0;
while(i<l&&str[i]!='('&&str[i]!=')'&&str[i]!=',')
p->data[j++]=str[i++];
--i;
p->data[j]='\0';
p->lchild=p->rchild=NULL;
if(!b)
b=p;
else
switch(k)
{
case 1:
St[top]->lchild=p;
break;
case 2:
St[top]->rchild=p;
break;
}
}
}
bool Symm(BTNode *b1,BTNode *b2)
{
if(!b1&&!b2)
return true;
if(!b1||!b2)
return false;
if(strcmp(b1->data,b2->data)!=0)
return false;
return Symm(b1->lchild,b2->rchild)&&Symm(b1->rchild,b2->lchild);
}
bool Symmtree(BTNode *b)
{
if(!b)
return true;
return Symm(b->lchild,b->rchild);
}
void DestroyBT(BTNode *&b)
{
if(b->lchild)
DestroyBT(b->lchild);
if(b->rchild)
DestroyBT(b->rchild);
free(b);
}
int main()
{
while(~scanf("%s",str))
{
BTNode *b;
CreateBTNode(b);
puts(Symmtree(b)?"YES":"NO");
DestroyBT(b);
}
}B. 拮据的模拟城市
这道题的题意其实非常明确，就是要求最小生成树的各边权值和。唯一要注意的是图中可以有重边，所以使用邻接矩阵建图时需要注意。
这里我给出kruskal和prim两种做法的标程。
#include<cstdio>
#include<algorithm>
using namespace std;
const int MAXN=1005;
const int MAXM=100005;
struct edge
{
int u,v,w;
edge(int _u=0,int _v=0,int _w=0):u(_u),v(_v),w(_w) {}
bool operator<(const edge &oth) const
{
return w<oth.w;
}
} e[MAXM];
int n,m;
int u[MAXN];
void init()
{
for(int i=1; i<=n; ++i)
u[i]=i;
}
int find(int x)
{
if(u[x]!=x)
u[x]=find(u[x]);
return u[x];
}
void merge(int x,int y)
{
u[find(x)]=find(y);
}
int kruskal()
{
sort(e,e+m);
int ret=0,cnt=0;
init();
for(int i=0; cnt<n-1&&i<m; ++i)
if(find(e[i].u)!=find(e[i].v))
{
merge(e[i].u,e[i].v);
ret+=e[i].w;
++cnt;
}
return ret;
}
int main()
{
while(~scanf("%d%d",&n,&m))
{
for(int i=0; i<m; ++i)
scanf("%d%d%d",&e[i].u,&e[i].v,&e[i].w);
printf("%d\n",kruskal());
}
}#include<cstdio>
#include<cstring>
using namespace std;
const int MAXN=1005;
const int INF=0x3f3f3f3f;
int g[MAXN][MAXN],n,lowc[MAXN];
int prim()
{
for(int i=1; i<=n; ++i)
lowc[i]=g[1][i];
int ret=0;
for(int i=1; i<n; ++i)
{
int mark=-1,minc=INF;
for(int j=1; j<=n; ++j)
if(lowc[j]&&minc>lowc[j])
{
minc=lowc[j];
mark=j;
}
ret+=minc;
lowc[mark]=0;
for(int j=1; j<=n; ++j)
if(lowc[j]&&lowc[j]>g[mark][j])
lowc[j]=g[mark][j];
}
return ret;
}
int main()
{
int m,u,v,l;
while(~scanf("%d%d",&n,&m))
{
memset(g,0x3f,sizeof(g));
for(int i=1; i<=n; ++i)
g[i][i]=0;
while(m--)
{
scanf("%d%d%d",&u,&v,&l);
if(l<g[u][v])
g[u][v]=g[v][u]=l;
}
printf("%d\n",prim());
}
}C. 迷宫里有一只薛定谔的猫!
这道题要求的，是从1点到其余所有点的最短距离的期望。所以跑一遍单源最短路就可以了，要注意的依然是重边问题。
关于单源最短路，书中只给出了dijkstra算法，事实上这不是唯一的单源最短路算法。我这里给出dijkstra+邻接矩阵和spfa+邻接表的两种标程。
#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
const int MAXN=505;
const int INF=0x3f3f3f3f;
int g[MAXN][MAXN],dist[MAXN],n;
bool vis[MAXN];
void dijkstra(int src)
{
memset(dist,0x3f,sizeof(dist));
memset(vis,false,sizeof(vis));
dist[src]=0;
for(int i=0; i<n; ++i)
{
pair<int,int> tmp=make_pair(INF,-1);
for(int j=1; j<=n; ++j)
if(!vis[j]&&dist[j]<tmp.first)
tmp=make_pair(dist[j],j);
if(!~tmp.second)
break;
vis[tmp.second]=true;
for(int j=1; j<=n; ++j)
dist[j]=min(dist[j],tmp.first+g[tmp.second][j]);
}
}
int main()
{
int m,a,b,l;
while(~scanf("%d%d",&n,&m))
{
memset(g,0x3f,sizeof(g));
for(int i=1; i<=n; ++i)
g[i][i]=0;
while(m--)
{
scanf("%d%d%d",&a,&b,&l);
g[a][b]=min(g[a][b],l);
}
dijkstra(1);
double ans=0;
for(int i=1; i<=n; ++i)
ans+=dist[i];
printf("%.2f\n",ans/(n-1));
}
}#include<cstdio>
#include<cstring>
#include<queue>
using namespace std;
const int MAXN=505;
const int MAXM=MAXN*MAXN;
struct graph
{
int head[MAXN];
int to[MAXM];
int next[MAXM];
int len[MAXM];
int tot;
void init()
{
tot=0;
memset(head,0xff,sizeof(head));
}
void add(int u,int v,int w)
{
to[tot]=v;
len[tot]=w;
next[tot]=head[u];
head[u]=tot++;
}
} g;
int dist[MAXN];
bool inque[MAXN];
void spfa(int src)
{
memset(dist,0x3f,sizeof(dist));
memset(inque,false,sizeof(inque));
dist[src]=0;
queue<int> q;
q.push(src);
inque[src]=true;
while(!q.empty())
{
int u=q.front();
q.pop();
inque[u]=false;
for(int i=g.head[u]; ~i; i=g.next[i])
{
int v=g.to[i];
if(dist[u]+g.len[i]<dist[v])
{
dist[v]=dist[u]+g.len[i];
if(!inque[v])
{
q.push(v);
inque[v]=true;
}
}
}
}
}
int main()
{
int n,m,a,b,l;
while(~scanf("%d%d",&n,&m))
{
g.init();
while(m--)
{
scanf("%d%d%d",&a,&b,&l);
g.add(a,b,l);
}
spfa(1);
double ans=0;
for(int i=1; i<=n; ++i)
ans+=dist[i];
printf("%.2f\n",ans/(n-1));
}
}另外说一句，设V是点数，E是边数；标准的dijkstra算法，使用邻接矩阵，复杂度是O(V^2)的，使用堆优化或者优先队列优化，再使用恰当的建图方式，可以有效降低复杂度。标准spfa算法，使用邻接表，复杂度大概是O(k*E)，k根据图的不同，可能很小，也可能大到接近V，用某些优化方法可以使k减小。换言之，应该根据图的特性（稠密图？稀疏图？）来选择最合适的算法。
D. 迷宫里有两只薛定谔的猫!
这道题是求任意两点之间最短距离的期望。或许因为和上一题太像，许多人选择在每一个点上都跑一次dijkstra算法。方法上没有问题，但为什么不使用floyd算法呢……在多源最短路的问题上，floyd算法显然代码更短，效率更高。
#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
const int MAXN=205;
const int INF=0x3f3f3f3f;
int g[MAXN][MAXN],n;
void floyd()
{
for(int k=1; k<=n; ++k)
for(int i=1; i<=n; ++i)
for(int j=1; j<=n; ++j)
g[i][j]=min(g[i][j],g[i][k]+g[k][j]);
}
int main()
{
int m,a,b,l;
while(~scanf("%d%d",&n,&m))
{
memset(g,0x3f,sizeof(g));
for(int i=1; i<=n; ++i)
g[i][i]=0;
while(m--)
{
scanf("%d%d%d",&a,&b,&l);
if(l<g[a][b])
g[a][b]=g[b][a]=l;
}
floyd();
double ans=0;
for(int i=1; i<=n; ++i)
for(int j=1; j<=n; ++j)
ans+=g[i][j];
printf("%.2f\n",ans/(n*(n-1)));
}
}E. 迷宫里有一只深井冰!
这道题，大概是渣诚满满的恶意……这是一道基础的TSP旅行商问题，是一个NP问题，这也意味着它并没有多项式复杂度的解法，所以不属于各种最短路算法的范畴；从至多10个点的数据量大概也可以看出，我们只是想让大家写一发暴搜。
不过暴力也是有很多方法的，我的做法相当于取了个巧；假设从0点出发，用next_permutation()函数穷举出所有以0开头的排列，然后计算这种排列代表的走法的路径长度，取最短的即可。这样暴力的复杂度是O(n!)。
另外，这道题是可以状压dp的，可以把复杂度降到O(n^2*2^n)，有兴趣的童鞋可以研究一下。简单地说，设从0点出发，dp(i,j)表示在状态i下访问到j点的最短路径长度，则dp((1<<n)-1,k)就表示遍历过所有点且以k点为终点的最短路径长度。
#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
const int INF=0x3f3f3f3f;
int g[10][10],s[10];
int main()
{
int n;
while(~scanf("%d",&n))
{
for(int i=0; i<n; ++i)
for(int j=0; j<n; ++j)
scanf("%d",&g[i][j]);
for(int i=0; i<n; ++i)
s[i]=i;
int ans=INF;
while(s[0]==0)
{
int tmp=g[s[n-1]][s[0]];
for(int i=1; i<n; ++i)
tmp+=g[s[i-1]][s[i]];
ans=min(ans,tmp);
next_permutation(s,s+n);
}
printf("%d\n",ans);
}
}#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
const int INF=0x3f3f3f3f;
int g[10][10],dp[10][1<<10];
int main()
{
int n;
while(~scanf("%d",&n))
{
for(int i=0; i<n; ++i)
for(int j=0; j<n; ++j)
scanf("%d",&g[i][j]);
memset(dp,0x3f,sizeof(dp));
dp[0][1]=0;
for(int i=1; i<(1<<n); i+=2)
for(int j=0; j<n; ++j)
if(i&(1<<j))
for(int k=0; k<n; ++k)
if(!(i&(1<<k)))
dp[k][i|(1<<k)]=min(dp[k][i|(1<<k)],dp[j][i]+g[j][k]);
int ans=INF;
for(int i=1; i<n; ++i)
ans=min(ans,dp[i][(1<<n)-1]+g[i][0]);
printf("%d\n",ans);
}
}F. 结点距离下集
这是一道陈题，也是我觉得出题有失误的一道题。倒不是因为这道题所需知识超出了范围，而是这道题的题目描述相当不清晰。题目实际是在描述这样一个图，首先这个图是一个森林（对，没有环），在森林中的每棵树都有这样的特点，就是其中有一个节点是根节点（即题目中的集换中心），而其它节点的度（双向边，无所谓入度出度）小于等于2，形象一点地说，就是每一棵树都像神经元一样，根节点是细胞体，其余节点都在各条突触上，且每条突触不会分叉。
所以，在当前的知识储备下，做法就是先遍历整个森林，找到每棵树上的根节点（统计度数就可以了，如果所有节点的度数都小于等于2，则这棵树必定是一条链，可以任选一个节点作为根节点）；然后，再从根节点出发，对每棵树进行遍历，并记录每个节点的深度，和所在链的编号。这样，任意一棵树中的两个节点，倘若在一条链上，其最小距离就是深度的差，倘若不在一条链上，其距离就是深度的和（因为要通过根节点）。放一下渣诚的标程作为参考。
//trashLHC
#include<iostream>
#include<cstdio>
#include<cmath>
#include<cstdlib>
#define MAXV 100001
int a[MAXV],b[MAXV];
typedef struct ANode
{
int adjvex;
struct ANode *nextarc;
int info;
int router;
}ArcNode;
typedef struct Vnode
{
int data;
ArcNode *firstarc;
}VNode;
typedef VNode AdjList[MAXV];
typedef struct
{
AdjList adjlist;
int n,e;
}ALGraph;
int visited[MAXV];
void CreateList(ALGraph *&G,int n,int l)
{
int i,j;
ArcNode *p,*q;
G=(ALGraph *)malloc(sizeof(ALGraph));
for(i=0;i<=n;i++)
G->adjlist[i].firstarc=NULL;
for(i=0;i<l;i++)
{
p=(ArcNode *)malloc(sizeof(ArcNode));
p->adjvex=b[i];
p->nextarc=G->adjlist[a[i]].firstarc;
G->adjlist[a[i]].firstarc=p;
q=(ArcNode *)malloc(sizeof(ArcNode));
q->adjvex=a[i];
q->nextarc=G->adjlist[b[i]].firstarc;
G->adjlist[b[i]].firstarc=q;
}
G->n=n;G->e=l;
}
int route=0;
int length=0;
int distance[MAXV];
int rout[MAXV];
void DFS(ALGraph *G,int v)
{
ArcNode *p,*q;
visited[v]=1;
p=G->adjlist[v].firstarc;
p->router=route;
p->info=length;
distance[v]=p->info;
rout[v]=p->router;
while(p!=NULL)
{
if(!visited[p->adjvex])
break;
p=p->nextarc;
}
if(p==NULL)
{
route++;
length=0;
}
p=G->adjlist[v].firstarc;
while(p!=NULL)
{
if(!visited[p->adjvex])
{
length++;
DFS(G,p->adjvex);
}
p=p->nextarc;
}
}
void DetroyGraph(ALGraph *&G)
{
ArcNode *p,*q;
for(int i=0;i<=G->n;i++)
{
p=G->adjlist[i].firstarc;
while(p!=NULL)
{
q=p;
p=p->nextarc;
free(q);
}
}
free(G);
}
int main()
{
int t;
scanf("%d",&t);
while(t--)
{
int m,n;
scanf("%d%d",&m,&n);
ALGraph *G2;
int max=0;
int counter[MAXV];
for(int i=0;i<=m;i++)
{
counter[i]=0;
distance[i]=0;
rout[i]=0;
visited[i]=0;
}
for(int i=0;i<m;i++)
{
scanf("%d%d",&a[i],&b[i]);
counter[a[i]]++;counter[b[i]]++;
}
int recorder=0;
for(int i=0;i<=m;i++)
if(max<counter[i])
{
recorder=i;
max=counter[i];
}
CreateList(G2,m,m);
DFS(G2,recorder);
for(int i=0;i<n;i++)
{
int temp1,temp2;
scanf("%d%d",&temp1,&temp2);
if(rout[temp1]==rout[temp2])printf("%d\n",abs(distance[temp1]-distance[temp2]));
else printf("%d\n",distance[temp1]+distance[temp2]);
}
route=0;
length=0;
DetroyGraph(G2);
}
}而我不是这么做的，我的做法超出了课程范围，不过适用范围会更广一些，只要保证图是一个森林就可以了，对每棵树的具体形状并没有要求，这里简单说一下供有兴趣的童鞋探究。我的做法是处理出树上任意两点的lca，即最近公共祖先，则这两点的距离就是这两点的深度之和减去2×最近公共祖先的深度。处理lca的方法有两种，一种是在线倍增法，复杂度是O(nlogn)，一种是离线Tarjan算法，复杂度上O(n)。下面分别放出两种做法的标程。
//by wjfwzzc
//lca+倍增
#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
const int MAXN=100005;
const int MAXM=200005;
const int maxd=17;
struct graph
{
int head[MAXN];
int to[MAXM];
int next[MAXM];
int tot;
void init()
{
tot=0;
memset(head,0xff,sizeof(head));
}
void add(int u,int v)
{
to[tot]=v;
next[tot]=head[u];
head[u]=tot++;
}
} g;
int d[MAXN],f[MAXN][maxd];
void dfs(int u,int fa)
{
f[u][0]=fa;
for(int i=1; i<maxd; ++i)
f[u][i]=f[f[u][i-1]][i-1];
for(int i=g.head[u]; ~i; i=g.next[i])
{
int v=g.to[i];
if(v!=fa)
{
d[v]=d[u]+1;
dfs(v,u);
}
}
}
int lca(int u,int v)
{
if(d[u]<d[v])
swap(u,v);
int k=d[u]-d[v];
for(int i=0; i<maxd; ++i)
if((1<<i)&k)
u=f[u][i];
if(u==v)
return u;
for(int i=maxd-1; i>=0; --i)
if(f[u][i]!=f[v][i])
{
u=f[u][i];
v=f[v][i];
}
return f[u][0];
}
int main()
{
int t,m,n,a,b;
scanf("%d",&t);
while(t--)
{
g.init();
scanf("%d%d",&m,&n);
while(m--)
{
scanf("%d%d",&a,&b);
g.add(a,b);
g.add(b,a);
}
d[0]=0;
dfs(0,-1);
while(n--)
{
scanf("%d%d",&a,&b);
printf("%d\n",d[a]+d[b]-2*d[lca(a,b)]);
}
}
}
//by wjfwzzc
//lca+Tarjan
#include<cstdio>
#include<cstring>
using namespace std;
const int MAXN=100005;
const int MAXM=200005;
struct graph
{
int head[MAXN];
int to[MAXM];
int idx[MAXM];
int next[MAXM];
int tot;
void init()
{
tot=0;
memset(head,0xff,sizeof(head));
}
void add(int u,int v,int w=-1)
{
to[tot]=v;
idx[tot]=w;
next[tot]=head[u];
head[u]=tot++;
}
} g,q;
int x[MAXN],y[MAXN],z[MAXN];
int f[MAXN],d[MAXN];
bool vis[MAXN];
int find(int x)
{
if(f[x]!=x)
return f[x]=find(f[x]);
return f[x];
}
void tarjan(int u)
{
vis[u]=true;
f[u]=u;
for(int i=q.head[u]; ~i; i=q.next[i])
{
int v=q.to[i];
if(vis[v])
z[q.idx[i]]=find(v);
}
for(int i=g.head[u]; ~i; i=g.next[i])
{
int v=g.to[i];
if(!vis[v])
{
d[v]=d[u]+1;
tarjan(v);
f[v]=u;
}
}
}
int main()
{
int t,m,n,a,b;
scanf("%d",&t);
while(t--)
{
g.init();
scanf("%d%d",&m,&n);
while(m--)
{
scanf("%d%d",&a,&b);
g.add(a,b);
g.add(b,a);
}
q.init();
for(int i=1; i<=n; ++i)
{
scanf("%d%d",&x[i],&y[i]);
q.add(x[i],y[i],i);
q.add(y[i],x[i],i);
}
memset(vis,false,sizeof(vis));
d[0]=0;
tarjan(0);
for(int i=1; i<=n; ++i)
printf("%d\n",d[x[i]]+d[y[i]]-2*d[z[i]]);
}
}G. Fibonacci Tree
这是我在2013年ACM成都现场赛做过的原题，网上自然有很多题解；但有十余位童鞋选择直接照搬网上代码还是很令人寒心。这道题是说权值只有1和0两种的一个图，问其是否存在权值和为Fibonacci数的生成树。直接做一遍最小生成树和最大生成树（最小生成树的两种算法本质都是贪心，所以可以很容易地改写出求最大生成树），然后注意到，我们假设把得到的最小生成树逐边修改得到最大生成树，在修改的过程中，必然会出现把0边改成1边这样的情况，换言之，最小生成树和最大生成树的权值之间形成的区间，一定是致密的，再换种说法，这个区间内任何一个值对应的生成树必然存在；所以，我们只要判断是否有Fibonacci数存在于这个区间内就可以了。所以最后的做法是预处理出一些Fibonacci数（30个左右即可），然后在求出最小生成树和最大生成树之后，穷举Fibonacci数进行判断即可。这里给出使用kruskal和prim两种算法的标程。
#include<cstdio>
#include<algorithm>
using namespace std;
const int MAXN=1005;
const int MAXM=100005;
struct edge
{
int u,v,w;
edge(int _u=0,int _v=0,int _w=0):u(_u),v(_v),w(_w) {}
} e[MAXM];
bool cmp1(const edge &a,const edge &b)
{
return a.w<b.w;
}
bool cmp2(const edge &a,const edge &b)
{
return a.w>b.w;
}
bool (*cmp[])(const edge&,const edge&)= {cmp1,cmp2};
int n,m;
int u[MAXN];
void init()
{
for(int i=1; i<=n; ++i)
u[i]=i;
}
int find(int x)
{
if(u[x]!=x)
u[x]=find(u[x]);
return u[x];
}
void merge(int x,int y)
{
u[find(x)]=find(y);
}
int kruskal(int k)
{
sort(e,e+m,cmp[k]);
int ret=0,cnt=0;
init();
for(int i=0; cnt<n-1&&i<m; ++i)
if(find(e[i].u)!=find(e[i].v))
{
merge(e[i].u,e[i].v);
ret+=e[i].w;
++cnt;
}
return cnt<n-1?-1:ret;
}
int main()
{
int f[30];
f[0]=1;
f[1]=2;
for(int i=2; i<30; ++i)
f[i]=f[i-1]+f[i-2];
while(~scanf("%d%d",&n,&m))
{
for(int i=0; i<m; ++i)
scanf("%d%d%d",&e[i].u,&e[i].v,&e[i].w);
int amin=kruskal(0),amax=kruskal(1);
bool flag=false;
if(~amin&&~amax)
for(int i=0; !flag&&i<30; ++i)
if(amin<=f[i]&&amax>=f[i])
flag=true;
puts(flag?"Yes":"No");
}
}#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
const int MAXN=1005;
const int INF=0x3f3f3f3f;
bool lvis[MAXN],hvis[MAXN];
int g[MAXN][MAXN][2],n,lc[MAXN],hc[MAXN],amin,amax;
void prim()
{
memset(lvis,false,sizeof(lvis));
memset(hvis,false,sizeof(hvis));
for(int i=1; i<=n; ++i)
{
lc[i]=g[1][i][0];
hc[i]=g[1][i][1];
}
lvis[1]=hvis[1]=true;
amin=amax=0;
for(int i=1; i<n; ++i)
{
int lmark=-1,hmark=-1,lminc=INF,hminc=-1;
for(int j=1; j<=n; ++j)
{
if(!lvis[j]&&lminc>lc[j])
{
lminc=lc[j];
lmark=j;
}
if(!hvis[j]&&hminc<hc[j])
{
hminc=hc[j];
hmark=j;
}
}
if(!~lmark)
{
amin=-1;
break;
}
if(!~hmark)
{
amax=-1;
break;
}
lvis[lmark]=hvis[hmark]=true;
amin+=lc[lmark];
amax+=hc[hmark];
for(int j=1; j<=n; ++j)
{
if(!lvis[j]&&lc[j]>g[lmark][j][0])
lc[j]=g[lmark][j][0];
if(!hvis[j]&&hc[j]<g[hmark][j][1])
hc[j]=g[hmark][j][1];
}
}
}
int main()
{
int f[30];
f[0]=1;
f[1]=2;
for(int i=2; i<30; ++i)
f[i]=f[i-1]+f[i-2];
int m,a,b,c;
while(~scanf("%d%d",&n,&m))
{
for(int i=1; i<=n; ++i)
{
for(int j=1; j<=n; ++j)
{
g[i][j][0]=INF;
g[i][j][1]=-1;
}
g[i][i][0]=g[i][i][1]=0;
}
while(m--)
{
scanf("%d%d%d",&a,&b,&c);
if(c<g[a][b][0])
g[a][b][0]=g[b][a][0]=c;
if(c>g[a][b][1])
g[a][b][1]=g[b][a][1]=c;
}
prim();
bool flag=false;
if(~amin&&~amax)
for(int i=0; !flag&&i<30; ++i)
if(amin<=f[i]&&amax>=f[i])
flag=true;
puts(flag?"Yes":"No");
}
}最后我想说，上机愈少，期末临近，且练且珍惜。
689
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
