第一题
模拟在一个不重复字符键盘上
输出一个指定字符串要要多大代价?
最开始在0，0的位置
移动一格需要x的代价
敲击一个字符要z的代价
发生转向要y的代价

输入
n，m，x，y，z
n代表输入n行，m代表每行字符数

样例
2 2 1 1 1
.E
:F
EE:F.:

输出
15

import java.util.HashMap;
import java.util.Scanner;

/**
 * @data 2021/9/11 18:47
 **/
public class Main {
    public static void main(String[] args) {
        Scanner s = new Scanner(System.in);
        int n = s.nextInt();
        int m = s.nextInt();
        int x = s.nextInt();
        int y = s.nextInt();
        int z = s.nextInt();
        HashMap<Character,point> hmap = new HashMap<>();
        String ss;
        s.nextLine();
        for(int i=0;i<n;i++){
            ss = s.next();
            for(int j=0;j<m;j++){
                point p = new point(i,j);
                hmap.put(ss.charAt(j),p);
            }
        }
        ss = s.next();
        point p = new point(0,0);
        point temp;
        long sum = 0;
        for(int i=0;i<ss.length();i++){
            temp = hmap.get(ss.charAt(i));
            //移动的距离
            sum += p.dist(temp) * x;
            sum += z;
            if(p.judge(temp)){
                sum += y;
            }
            p = temp;
        }
        System.out.println(sum);
    }
    public static class point
    {
        int x;
        int y;
        
        public point(int x, int y) {
            this.x = x;
            this.y = y;
        }
        public int dist(point p){
            return Math.abs(x-p.x) + Math.abs(y-p.y);
        }
        public boolean judge(point p){
            if(Math.abs(x-p.x) > 0 && Math.abs(y-p.y) > 0){
                return true;
            }
            return false;
        }
    }
}

第二题
一共有n个服务，服务之间会有依赖关系，如果a依赖于b，开启a就要一起开启b，关闭b，就会把a也关闭，刚开始服务都是关闭的，经过一些操作之后输出当前开启服务的数量。
输入格式
n，q
之后n行 先输入一个c，之后c个字符表示第i项的依赖
之后q行 每行两个数，第一个数是1表示开启服务，后面是开启服务项
如果是0表示关闭服务，后面接一个关闭的服务项
样例
3 2
1 2
1 3
0
1 1
0 2
输出
3
1

public class Main {
    public static void main(String[] args) {
        Scanner s = new Scanner(System.in);
        int n = s.nextInt();
        int q = s.nextInt();
        boolean[] visit = new boolean[n];
        boolean[][] al = new boolean[n+1][n+1];
        boolean[][] bl = new boolean[n+1][n+1];
        int c,d;
        for(int i=1;i<=n;i++){
            c = s.nextInt();
            for(int j=0;j<c;j++){
                d = s.nextInt();
                al[i][d] = true;
                bl[d][i] = true;
            }
        }
        solve(al,n);
        solve(bl,n);
        for(int i=0;i<q;i++){
            c = s.nextInt();
            if(c==1){
                d = s.nextInt();
                visit[d-1] = true;
               for(int j=1;j<=n;j++){
                   if(al[d][j]){
                       visit[j-1] = true;
                   }
               }
                System.out.println(sum(visit));
            }
            else{
                d = s.nextInt();
                visit[d-1] = false;
                for(int j=1;j<=n;j++){
                    if(bl[d][j]){
                        visit[j-1] = false;
                    }
                }
                System.out.println(sum(visit));
            }
        }
    }
    public static int sum(boolean[] visit){
        int sum = 0;
        for(int i=0;i<visit.length;i++){
            if(visit[i]){
                sum++;
            }
        }
        return sum;
    }
    public static void solve(boolean[][] v,int n){
        for(int i=1;i<=n;i++){
            for(int j=1;j<=n;j++){
                if(v[i][j]){
                    for(int k=1;k<=n;k++){
                        v[i][k] = v[i][k] || v[j][k];
                    }
                }
            }
        }
        for(int i=1;i<=n;i++){
            for(int j=1;j<=n;j++){
                if(v[i][j]){
                    for(int k=1;k<=n;k++){
                        v[i][k] = v[i][k] || v[j][k];

                    }
                }
            }
        }
    }
    public static void print(boolean[][] v){
        for(int i=1;i<v.length;i++){
            System.out.println(Arrays.toString(v[i]));
        }
    }
}