蓝桥杯--图及其它（一）

1)	图与树的关系和转化
2)	图的基本遍历
3)	利用树的性质
4)	线段树与并查集介绍

例1【求连通性】

给定一个方阵，定义连通：上下左右相邻，并且值相同。
可以想象成一张地图，不同的区域被涂以不同颜色。
输入：
整数N, (N<50)表示矩阵的行列数
接下来N行，每行N个字符，代表方阵中的元素
接下来一个整数M，(M<1000)表示询问数
接下来M行，每行代表一个询问，
格式为4个整数，y1,x1,y2,x2，
表示(第y1行,第x1列) 与 (第y2行,第x2列) 是否连通。
连通输出true，否则false

例如：
10
0010000000
0011100000
0000111110
0001100010
1111010010
0000010010
0000010011
0111111000
0000010000
0000000000
3
0 0 9 9
0 2 6 8
4 4 4 6

程序应该输出：
false
true
true

解析：这是图的深度优先遍历的典型应用

public class Main {
    public static boolean lian_tong(char[][]data,int y1,int x1,int y2,int x2) {
        if(y1==y2 && x1==x2 )
            return true;
        char old = data[y1][x1];
        data[y1][x1] = '*';//标记已访问的点，试探
        try{
            if(y1<data.length-1 && data[y1+1][x1]==old && lian_tong(data,y1+1,x1,y2,x2))
                return true;
            if(y1>0 && data[y1-1][x1]==old && lian_tong(data,y1-1,x1,y2,x2))
                return true;
            if(x1>0 && data[y1][x1-1]==old && lian_tong(data,y1,x1-1,y2,x2))
                return true;
            if(x1<data.length-1 && data[y1][x1+1]==old && lian_tong(data,y1,x1+1,y2,x2))
                return true;
        }
        finally {
            data[y1][x1] = old;//回溯
        }
        return false;
    }

    public static void main(String[] args) {
        Scanner sc=new Scanner(System.in);
        //n:矩阵的行列式
        int n=Integer.parseInt(sc.nextLine());
        //输入n行n列，用二维数组接收
        char [][] data=new char[n][];
        for(int i=0;i<n;i++){
            data[i]=sc.nextLine().toCharArray();
        }
        //计算n次是否连通
        int m=Integer.parseInt(sc.nextLine());
        for(int i=0;i<m;i++) {
            String []s=sc.nextLine().split(" ");
            int x1=Integer.parseInt(s[0]);
            int y1=Integer.parseInt(s[1]);
            int x2=Integer.parseInt(s[2]);
            int y2=Integer.parseInt(s[3]);
            System.out.println(lian_tong(data,x1,y1,x2,y2));
        }
    }
}

例2【迷宫问题-最短路径】

如下图的迷宫，入口，出口分别：左上角，右下角
"1"是墙壁，"."是通路
求最短需要走多少步？

...11111111111111111111111111111
11.111111........1111111111.1111
11.111111..111.11111111.....1111
11.11111111111.1111111111.111111
11.111111.................111111
11.111111.11111111111.11111.1111
11.111111.11111111111.11111..111
11..........111111111.11111.1111
11111.111111111111111.11....1111
11111.111111111111111.11.11.1111
11111.111111111111111.11.11.1111
111...111111111111111.11.11.1111
111.11111111111111111....11.1111
111.11111111111111111111111.1111
111.1111.111111111111111......11
111.1111.......111111111.1111.11
111.1111.11111.111111111.1111.11
111......11111.111111111.1111111
11111111111111.111111111.111...1
11111111111111...............1.1
111111111111111111111111111111..

解析：图的广度优先遍历的典型应用

public class Main {
    static int f(char[][] data, Set<String> from, String goal) {
        if(from.contains(goal))
            return 0;
        Set<String> set = new HashSet();//存储from相邻的所有未访问点
        for(String s:from){
            String[]ss = s.split(",");
            int y = Integer.parseInt(ss[0]);
            int x = Integer.parseInt(ss[1]);
            if(y>0 && data[y-1][x]=='.'){
                set.add(y-1 + ","+ x);
                data[y-1][x]='*';
            }
            if(y<data.length-1 && data[y+1][x]=='.'){
                set.add(y+1 + ","+ x);
                data[y+1][x]='*';
            }
            if(x>0 && data[y][x-1]=='.'){
                set.add(y + ","+ (x-1));
                data[y][x-1]='*';
            }
            if(x<data[0].length-1 && data[y][x+1]=='.'){
                set.add(y + ","+ (x+1));
                data[y][x+1]='*';
            }
        }
        if(set.isEmpty())
            return -1;
        int r = f(data,set,goal);
        if(r<0)
            return -1;
        return r+1;
    }

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);//21 32
        String []ss = sc.nextLine().trim().split(" +");
        int m = Integer.parseInt(ss[0]);
        int n = Integer.parseInt(ss[1]);

        char [][] data = new char[m][];
        for(int i=0;i<m;i++) {
            data[i] = sc.nextLine().toCharArray();
        }

        Set<String> from = new HashSet();
        from.add("0,0");
        System.out.println(f(data,from,m-1+","+(n-1)));//61
    }
}

 

例3【分酒问题】

有4个红酒瓶子，它们的容量分别是：9升, 7升, 4升, 2升  
开始的状态是 [9,0,0,0]，也就是说：第一个瓶子满着，其它的都空着。

允许把酒从一个瓶子倒入另一个瓶子，但只能把一个瓶子倒满或把一个瓶子倒空，不能有中间状态。
这样的一次倒酒动作称为1次操作。

假设瓶子的容量和初始状态不变，对于给定的目标状态，至少需要多少次操作才能实现？
本题就是要求你编程实现最小操作次数的计算。
 
输入：最终状态（空格分隔）
输出：最小操作次数（如无法实现，则输出-1）

例如：
输入：
9 0 0 0
应该输出：
0

输入：
6 0 0 3
应该输出：
-1

输入：
7 2 0 0
应该输出：
2

解析：图的广度遍历求最短步骤（与上题相似）：将瓶子的初始容量看成一个状态，倒酒后看成另一个状态，每个状态都看成一个结点（状态一定是有限的）

public class Main {
    static int f(Set<String> history,Set<String> from, String goal) {
        if(from.contains(goal))
            return 0;
        Set<String> set = new HashSet<>();
        for(String s:from){
            set.addAll(move(s));
        }
        set.removeAll(history);
        if(set.isEmpty())
            return -1;
        history.addAll(set);
        int r = f(history,set,goal);
        if(r<0)
            return -1;
        return r+1;
    }

    static Set<String> move(String s){
        final int[]cap ={9,7,4,2};
        Set<String> set = new HashSet<>();
        String[]ss = s.split(" ");
        int [] data = new int[4];
        for(int i=0;i<4;i++)
            data[i] = Integer.parseInt(ss[i]);
        for(int i=0;i<4;i++){//源杯子
            for(int j=0;j<4;j++){//目标杯子
                if(i==j) continue;
                if(data[i]==0) continue;
                if(data[j]==cap[j]) continue;
                int sum = data[i] + data[j];
                int vi = 0;
                int vj = 0;
                if(sum<=cap[j]){
                    vi = 0;
                    vj = sum;
                }
                else{
                    vi = sum - cap[j];
                    vj = cap[j];
                }
                String news = "";//生成新的字符串
                for(int k=0;k<4;k++){
                    if(k==i) news = news + vi + " ";
                    else if(k==j) news = news + vj + " ";
                    else news = news + data[k] + " ";
                }
                set.add(news.trim());

            }
        }
        return set;
    }

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        Set<String> from = new HashSet();//出发态
        from.add("9 0 0 0");
        Set history = new HashSet();//所有历史态
        history.addAll(from);
        System.out.println(f(history,from,sc.nextLine().trim()));

    }
}

例4【风险系数】

X星系的的防卫体系包含 n 个空间站。这 n 个空间站间有 m 条通信链路，构成通信网。
两个空间站间可能直接通信，也可能通过其它空间站中转。

对于两个站点x和y (x != y), 如果能找到一个站点z，使得：
当z被破坏后，x和y不连通，则称z为关于x,y的关键站点。

显然，对于给定的两个站点，关于它们的关键点的个数越多，通信风险越大。

你的任务是：已经网络结构，求两站点之间的通信风险度，即：它们之间的关键点的个数。

输入数据第一行包含2个整数n(2 <= n <= 1000), m(0 <= m <= 2000),分别代表站点数，链路数。
空间站的编号从1到n。通信链路用其两端的站点编号表示。
接下来m行，每行两个整数 u,v (1 <= u, v <= n; u != v)代表一条链路。
最后1行，两个数u,v，代表被询问通信风险度的两个站点。

输出：一个整数，如果询问的两点不连通则输出-1.

例如：
用户输入：
7 6
1 3
2 3
3 4
3 5
4 5
5 6
1 6
则程序应该输出：
2

方法1：从a当树根做dfs生成树，直到b点，那么b的所有祖先都是关键点

方法2：在dfs生成树的过程中，求出返祖最高的点，显然这个点的子树就不是关键点

public class Main {
    //re->dfs生成树:顶点->(访问过，深度，父结点，最高返祖)
    static void dfs(List<Integer> []gr,int [][]re,int v1,int v2){//深度遍历建生成树
        if(v1==v2) return;
        for(Integer i:gr[v1]){
            if(re[i][0]!=0){//碰到已访问的点
                fan_zu(re,v1,re[i][1]);//更新整个家族的返祖级
                continue;
            }
            re[i][0] = 1;
            re[i][1] =re[v1][1] + 1;
            re[i][2] =v1;
            re[i][3] =re[v1][1];
            dfs(gr,re,i,v2);
        }
    }

    static void fan_zu(int[][]re,int me,int depth){
        if(re[me][3]<=depth) return;
        re[me][3] = depth;
        fan_zu(re,re[me][2],depth);//通知父亲更新返祖值
    }

    static int solve(int [][]re,int root,int leaf) {
        int sum = 0;
        int p = leaf;
        int min = re[p][3];//当前最高返祖级
        while (true) {
            int parent = re[p][2];
            if (parent == 0 || parent == root)
                break;
            if (re[parent][1] <= min){
                sum++;//关键！！！
                //System.out.print(parent + "  ");
            }
            if (re[parent][3] < min)
                min = re[parent][3];
            p = parent;
        }
        System.out.println();
        return sum;
    }


    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        String []ss = sc.nextLine().trim().split(" ");
        int m = Integer.parseInt(ss[0]);//站点数
        int n = Integer.parseInt(ss[1]);//链路数
        List<Integer> [] gr = new List[m+1];//存放顶点
        for(int i=0;i<gr.length;i++)
            gr[i] = new Vector();
        int [][] re = new int[m+1][4];//dfs生成树:顶点->(访问过，深度，父结点，最高返祖)

        for(int i=0;i<n;i++){
            ss = sc.nextLine().trim().split(" ");
            int v1 = Integer.parseInt(ss[0]);
            int v2 = Integer.parseInt(ss[1]);
            gr[v1].add(v2);
            gr[v2].add(v1);
        }

        ss = sc.nextLine().trim().split(" ");
        int a = Integer.parseInt(ss[0]);
        int b = Integer.parseInt(ss[1]);
        re[a][0] = 1;
        re[a][1] = 0;
        re[a][2] = 0;
        re[a][3] = 0;
        dfs(gr,re,a,b);

        System.out.println(solve(re,a,b));

    }
}