NEFU 2013省赛训练三

原创于 2013-04-08 15:43:15 发布 · 697 阅读

0 ·

本内容遵循CC 4.0 BY-SA版权协议

收录于

NEFU

http://acm.nefu.edu.cn/JudgeOnline/contestlist.php?contest_id=93

A题：给你一棵树，有那么一个定义，对于每个节点A，如果以该节点为父节点的子树中所有节点权值都为素数，并且小于A的节点值，并且A的节点值也为素数，那么称A为素数节点，求这棵树中素数节点的总数。

思路：可以算是树形DP吧，dfs深搜所有节点，并记录当前父节点下子树中的最大值，以及是否存在非素数，最后判断一下每个节点即可。

刚开始建单向边，于是WA了之后发现我二了.....

#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>
#include <vector>
#include <set>
#include <map>
#include <queue>
using namespace std;
#define N 10005
#define M 20010
#define MAX 4000001
bool isprime[MAX];
void getprime()
{
    long long i,j;
    memset(isprime,1,sizeof(isprime));
    isprime[1]=0;
    for(i=2; i<MAX; i++)
        if(isprime[i])
        {
            for(j=i*i; j<MAX; j+=i)
                isprime[j]=0;
        }
}
int n;
int val[N],res,maxv[N];
bool isp[N],isg[N];
int head[N],to[M],next[M],edge;
inline void addedge(int u,int v)
{
    to[edge]=v,next[edge]=head[u],head[u]=edge++;
}
void init()
{
    for(int i=1; i<=n; i++)
        head[i]=-1;
    edge=res=0;
}
void dfs(int u,int pre)
{
    int v;
    isp[u]=isprime[val[u]];
    isg[u]=1;
    maxv[u]=val[u];
    for(int i=head[u]; ~i; i=next[i])
        if(to[i]!=pre)
        {
            dfs(v=to[i],u);
            isp[u]&=isp[v];
            if(maxv[u]<=maxv[v]) isg[u]=0;
            maxv[u]=max(maxv[u],maxv[v]);
        }
}
int main()
{
    int i,u,v;
    getprime();
    while(~scanf("%d",&n))
    {
        init();
        for(i=1; i<=n; i++)
            scanf("%d",&val[i]);
        for(i=0; i<n-1; i++)
        {
            scanf("%d%d",&u,&v);
            addedge(v,u);
            addedge(u,v);
        }
        dfs(1,1);
        for(i=1; i<=n; i++)
        {
            if(isp[i]&&isg[i])
                res++;
        }
        printf("%d\n\n",res);
    }
    return 0;
}

B题：

水题......

C题：给你n个pegs个位置，会扔m个plates，和t次移动次数，每次移动到i-1或i+1，或者不移动（不消耗t）。每次扔plate，上面放有一定数量的bananas，并且会扔在某个peg上。问刚开始在1位置，问在t次跳跃的限制下，最多能接到多少的bananas。

思路：DP，dp[i][j][k]表示当前在第i个位置时，剩余j次跳跃次数，和第k次扔的时候最大值，那么dp[i][j][k]=max(dp[i][j][k+1],max(dp[i-1][j-1][k+1],dp[i+1][j-1][k+1]))+data[j][i];

data[j][i]表示第j次扔在i上的bananas数量，这里用dfs来实现DP状态的更新

#include <iostream>
#include <cstdio>
#include <cstring>
#include <map>
#include <set>
#include <vector>
#include <queue>
#include <cmath>
using namespace std;
#define N 1000000
#define M 2000000
#define INF 1000000000
int pegs,plates,maxJump;
int data[101][101];
int dp[101][101][101];
inline int max(int a,int b)
{
    return a>b?a:b;
}
int dfs(int now,int restJump,int Plate)
{
    if(dp[now][restJump][Plate]!=-1) return dp[now][restJump][Plate];
    if(Plate==plates) return dp[now][restJump][Plate]=data[Plate][now];
    int ret=dfs(now,restJump,Plate+1);
    if(restJump)
    {
        if(now>1&&now<=pegs) ret=max(ret,dfs(now-1,restJump-1,Plate+1));
        if(now<pegs&&now>=1) ret=max(ret,dfs(now+1,restJump-1,Plate+1));
    }
    return dp[now][restJump][Plate]=ret+data[Plate][now];
}
int main()
{
    int i,pos,val;
    int k=1;
    while(~scanf("%d%d%d",&pegs,&plates,&maxJump))
    {
        memset(dp,-1,sizeof(dp));
        memset(data,0,sizeof(data));
        for(i=1; i<=plates; i++)
        {
            scanf("%d%d",&pos,&val);
            data[i][pos]=val;
        }
        printf("Scenario #%d\n",k++);
        printf("%d\n\n",dfs(1,maxJump,0));
    }
    return 0;
}

D题：输入n个字符串，再输入n-1个字符串，然后对比两次输入，输出第1次中没有出现在第2次中的字符串。

思路：用异或来检索比较OTZ，当然，用STL，什么的基本都是TLE的

#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>
#include <set>
#include <map>
#include <vector>
#include <queue>
#include <cmath>
using namespace std;
char s1[35];
char s2[35];
int main()
{
    int n,l,i,j;
    int ca=1;
    while(~scanf("%d",&n))
    {
        memset(s2,0,sizeof(s2));
        for(i=0; i<2*n-1; i++)
        {
            scanf("%s",s1);
            l=strlen(s1);
            for(j=0; j<l; j++)
                s2[j]^=s1[j];
        }
        printf("Scenario #%d\n",ca++);
        printf("%s\n\n",s2);
    }
    return 0;
}

D题：给你N个点，M条边，每条边有权值，再给你A,B,C三个点，求从C点出发到A和B的距离和的最小值。

思路：三次SPFA，将每个点到A,B,C的距离累加，最后求到三个点的距离和最小的那个就行了

#include <iostream>
#include <cstring>
#include <cstdio>
#include <queue>
using namespace std;
const int maxv=5001;
const int maxe=20002;
const long long oo=1000000000LL;
struct node
{
    int w,to,next;
} e[maxe];
int head[maxv];
long long dis[maxv];
long long sum[maxv];
int edge,n,m;
bool vis[maxv];
queue<int>q;
inline void add(int u,int v,int c)
{
    e[edge].to=v,e[edge].w=c,e[edge].next=head[u],head[u]=edge++;
}
bool spfa(int s)
{
    int v,i;
    while(!q.empty()) q.pop();
    for(i=1; i<=n; i++)
        dis[i]=oo;
    dis[s]=0;
    memset(vis,0,sizeof(vis));
    vis[s]=1;
    q.push(s);
    while(!q.empty())
    {
        int tmp=q.front();
        q.pop();
        for(i=head[tmp]; i!=-1; i=e[i].next)
        {
            if(dis[tmp]+e[i].w<dis[v=e[i].to])
            {
                dis[v]=dis[tmp]+e[i].w;
                if(!vis[v])
                {
                    vis[v]=true;
                    q.push(v);
                }
            }
        }
        vis[tmp]=false;
    }
    return true;
}
int main()
{
    int u,v,d,C,B,A,k=1;
    while(~scanf("%d%d",&n,&m))
    {
        edge=0;
        memset(head,-1,sizeof(head));
        memset(sum,0,sizeof(sum));
        scanf("%d%d%d",&C,&A,&B);
        while(m--)
        {
            scanf("%d%d%d",&u,&v,&d);
            add(u,v,d);
            add(v,u,d);
        }
        printf("Scenario #%d\n",k++);
        spfa(C);
        for(int i=1; i<=n; i++)
            sum[i]+=dis[i];
        spfa(A);
        for(int i=1; i<=n; i++)
            sum[i]+=dis[i];
        spfa(B);
        for(int i=1; i<=n; i++)
            sum[i]+=dis[i];
        long long ans=oo;
        for(int i=1; i<=n; i++)
            ans=min(ans,sum[i]);
        //cout<<dis[B]<<endl;
        if(ans==oo) printf("Can not go reach!\n\n");
        else cout<<ans<<endl<<endl;
    }
    return 0;
}