Bestcoder #53

最新推荐文章于 2016-04-17 20:51:35 发布

aksdrxzd

最新推荐文章于 2016-04-17 20:51:35 发布

阅读量338

点赞数

分类专栏： ACM 文章标签： bestcoder

本文链接：https://blog.csdn.net/aksdrxzd/article/details/48102483

版权

ACM 专栏收录该内容

74 篇文章 0 订阅

订阅专栏

迟到了半小时开打，不然rank还可以更好看点……

1001 Rikka with Graph

Time Limit: 2000/1000 MS (Java/Others) Memory Limit: 65536/65536 K (Java/Others)

/** Aug 29, 2015 7:39:29 PM
 * PrjName:Bc53-01
 * @author Semprathlon
 */
import java.io.*;
import java.util.*;
public class Main {

    /**
     * @param args
     */
    public static void main(String[] args) throws IOException{
        // TODO Auto-generated method stub
        StreamTokenizer in=new StreamTokenizer(new BufferedInputStream(System.in));
        PrintWriter out=new PrintWriter(System.out);
        while(in.nextToken()!=StreamTokenizer.TT_EOF){
            int n=(int)in.nval;
            in.nextToken();
            int m=(int)in.nval;
            boolean has=false;
            //out.println(n+"-"+m);
            for(int i=1;i<=m;i++){
                in.nextToken();
                int u=(int)in.nval;
                in.nextToken();
                int v=(int)in.nval;
                if (u==1&&v==n||u==n&&v==1)
                    has=true;
            }
            if (has)
                out.println(1+" "+n*(n-1)/2);
            else
                out.println(1+" "+1);
        }
        out.flush();
        out.close();
    }
}

如果点1与点n直接相连，那么就是距离最短了。

1002 Rikka with Tree

要同时满足不同与相似，就是要求结点数相等，各结点到树根1的距离分别相等（即深度分别相同），且存在父节点不同的结点。
可以说就是判断同一深度上的结点互换后是否能得到新的结构。
若有某一深度上的结点数多于一个，那么大概可以通过同层互换获得新的结构。

/** Aug 29, 2015 7:59:14 PM
 * PrjName:Bc53-02
 * @author Semprathlon
 */
import java.io.*;
import java.util.*;
public class Main {

    /**
     * @param args
     */
    final static int maxn=2010;
    static Graph G=new Graph(maxn);
    static int[] dep;
    static HashSet<Integer> st=new HashSet<Integer>();
    static void bfs(int st){
        Queue<Integer> que=new LinkedList<Integer>();
        que.add(st);
        while(!que.isEmpty()){
            int u=que.poll();
            for(int i=G.h[u];i>-1;i=G.edge[i].next){
                int v=G.edge[i].to;
                if (dep[v]>0) continue;
                dep[v]=dep[u]+1;
                que.add(v);
            }
        }
    }
    public static void main(String[] args) throws IOException{
        // TODO Auto-generated method stub
        StreamTokenizer in=new StreamTokenizer(new BufferedInputStream(System.in));
        PrintWriter out=new PrintWriter(System.out);
        while(in.nextToken()!=StreamTokenizer.TT_EOF){
            int n=(int)in.nval;
            G.clear();
            dep=new int[n+1];
            dep[1]=1;
            for(int i=1;i<n;i++){
                in.nextToken();
                int u=(int)in.nval;
                in.nextToken();
                int v=(int)in.nval;
                G.add(u, v);
                G.add(v, u);
            }
            bfs(1);
            boolean ans=true;
            st.clear();
            for(int i=1;i<=n;i++)
                if (st.contains(dep[i])){
                    ans=false;
                    break;
                }
                else
                    st.add(dep[i]);
            out.println(ans?"YES":"NO");
        }
        out.flush();
        out.close();
    }

}
class Edge{
    int to,next;
    Edge(int _u,int _v){
        to=_u;next=_v;
    }
}
class Graph{
    int[] h;
    int sz;
    Edge[] edge;
    Graph(int size){
        sz=size;
        h=new int[sz+1];
        edge=new Edge[sz+1];
        Arrays.fill(h, -1);
        h[0]=0;
    }
    void clear(){
        h=new int[sz+1];
        edge=new Edge[sz+1];
        Arrays.fill(h, -1);
        h[0]=0;
    }
    void add(int u,int v){
        edge[h[0]]=new Edge(v,h[u]);
        h[u]=h[0]++;
    }
}

然而错了。
适当地列举一些情况，发现若树的深度仅有2，那么它始终是特殊的。
可是加上这一判断仍不够。
进一步的举例发现，若树上非最底层有某一层结点多于一个，就能变换形成新结构

/** Aug 29, 2015 7:59:14 PM
 * PrjName:Bc53-02
 * @author Semprathlon
 */
import java.io.*;
import java.util.*;
public class Main {

    /**
     * @param args
     */
    final static int maxn=2010;
    static Graph G=new Graph(maxn);
    static int[] dep;
    static HashSet<Integer> st=new HashSet<Integer>();
    static void bfs(int st){
        Queue<Integer> que=new LinkedList<Integer>();
        que.add(st);
        while(!que.isEmpty()){
            int u=que.poll();
            for(int i=G.h[u];i>-1;i=G.edge[i].next){
                int v=G.edge[i].to;
                if (dep[v]>0) continue;
                dep[v]=dep[u]+1;
                que.add(v);
            }
        }
    }
    public static void main(String[] args) throws IOException{
        // TODO Auto-generated method stub
        StreamTokenizer in=new StreamTokenizer(new BufferedInputStream(System.in));
        PrintWriter out=new PrintWriter(System.out);
        while(in.nextToken()!=StreamTokenizer.TT_EOF){
            int n=(int)in.nval;
            G.clear();
            dep=new int[n+1];
            dep[1]=1;
            for(int i=1;i<n;i++){
                in.nextToken();
                int u=(int)in.nval;
                in.nextToken();
                int v=(int)in.nval;
                G.add(u, v);
                G.add(v, u);
            }
            bfs(1);
            boolean ans=true;
            st.clear();
            int maxd=0;
            for(int i=1;i<=n;i++)
                maxd=Math.max(dep[i], maxd);
            for(int i=1;i<=n;i++)
                if (st.contains(dep[i])){
                    if (dep[i]<maxd){
                        ans=false;
                        break;
                    }
                }
                else
                    st.add(dep[i]);
            if (maxd<3)
                ans=true;
            out.println(ans?"YES":"NO");
        }
        out.flush();
        out.close();
    }

}
class Edge{
    int to,next;
    Edge(int _u,int _v){
        to=_u;next=_v;
    }
}
class Graph{
    int[] h;
    int sz;
    Edge[] edge;
    Graph(int size){
        sz=size;
        h=new int[sz+1];
        edge=new Edge[sz+1];
        Arrays.fill(h, -1);
        h[0]=0;
    }
    void clear(){
        h=new int[sz+1];
        edge=new Edge[sz+1];
        Arrays.fill(h, -1);
        h[0]=0;
    }
    void add(int u,int v){
        edge[h[0]]=new Edge(v,h[u]);
        h[u]=h[0]++;
    }
}

这与题解中所说的“一棵树是独特的当且仅当任意处于每一个深度的点数是1 1 1 1 … 1 1 x”相符（我个人将这种形态称作“呈扫帚状”）

aksdrxzd

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Bestcoder #53

迟到了半小时开打，不然rank还可以更好看点……1001 Rikka with GraphTime Limit: 2000/1000 MS (Java/Others) Memory Limit: 65536/65536 K (Java/Others)/** Aug 29, 2015 7:39:29 PM * PrjName:Bc53-01 * @author Semprathlon */
复制链接

扫一扫