import java.util.HashSet;
import java.util.Scanner;
import java.util.Set;

public class Main1 {
    public static void main(String[] args) {
//        System.out.println("Hello Jobs!");
        Scanner scanner =new Scanner(System.in);
        String input = scanner.nextLine();

        Set<Integer> sets = new HashSet<>();

        for(String s : input.split(",")) {
            sets.add(Integer.parseInt(s));
        }
        System.out.println(sets.size());
        scanner.close();
    }
}

import java.util.Scanner;

public class Main3 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int m = sc.nextInt();
        int n = sc.nextInt();

        // map start
        int[][] map = new int[m][n];

        for(int i = 0; i < m; i++){
            for(int j = 0; j < n; j++){
                map[i][j] = sc.nextInt();
            }
        }
        // map end
        System.out.println(shortestPath(m - 1, n - 1, map));
    }

    public static int shortestPath(int m, int n, int[][] map) {
        int i, j;

        int dp[][] = new int[m+1][n+1];

        dp[0][0] = map[0][0];

        for ( i = 1; i <= m; i ++)
            dp[i][0] = dp[i - 1][0] + map[i][0];

        for ( j = 1; j <= n; j ++)
            dp[0][j] = dp[0][j - 1] + map[0][j];

        for ( i = 1; i <= m; i ++)
            for ( j = 1; j <= n; j ++)
                dp[i][j] = Math.min(dp[i][j - 1], dp[i - 1][j]) + map[i][j];

        return dp[m][n];

    }
}

第二题：按照分数分配饼干

输入
小伙伴们人数及每个人的积分：
6
3 6 3 5 6 2

输出
老师需要分配的最少饼干：10
按照顺序每人分配：1 2 1 2 3 1

输入
小伙伴们人数及每个人的积分：
10
2 4 2 6 1 7 8 9 2 1

输出
老师需要分配的最少饼干：19
按照顺序每人分配：1 2 1 2 1 2 3 4 2 1

import java.util.Scanner;

public class Main2 {
    public static void main(String[] args) {
        // write your code here
        Scanner sc = new Scanner(System.in);
        int N = sc.nextInt();
        int[] scores = new int[N];
        int[] cookies = new int[N];//每个小伙伴分配的cookie
        for (int i = 0; i < N; i ++) {
            scores[i] = sc.nextInt();
        }
        // 数据录入完毕
        
        // 先确定积分数组中，都比左右邻小的位置，按最少分配，每个人都只分配一个cookie
        for (int i = 1; i < N - 1; i ++) {
            if(scores[i] < scores[i + 1] && scores[i] < scores[i - 1]) {
                cookies[i] = 1;
            }
        }
        // 处理左边界
        if(scores[0] < scores[1]) {
            cookies[0] = 1;
        }
        // 处理右边界
        if(scores[scores.length - 1] < scores[scores.length - 2]) {
            cookies[cookies.length - 1] = 1;
        }

        // 从cookies数组中为1的元素的位置index向两边扩散，
        // 若积分数组从index位置向两边是递增的趋势，则cookies数组扩散的位置逐个递增1
        for (int i = 0; i < N; i ++) {
            if(cookies[i] == 1) {
                // 向右扩散
                for (int j = i + 1; j < N - 1; j ++) {
                    if(scores[j] > scores[j - 1]) {
                        // 如果已经扩散过的位置，再次被扩散，要保证最大值，才能满足两边都符合题目条件
                        cookies[j] = Math.max(cookies[j - 1] + 1, cookies[j]);
                    } else {
                        // 递增结束
                        break;
                    }
                }
                // 向左扩散
                for (int j = i - 1; j >   - 1; j --) {
                    if(scores[j] > scores[j + 1]) {
                        cookies[j] = Math.max(cookies[j + 1] + 1, cookies[j]);
                    } else {
                        break;
                    }
                }
            }
        }
        // cookies数组求和
        int ans = 0;

        for (int i = 0; i < N; i ++) {
            ans += cookies[i];
        }

        System.out.println(ans);
    }
}