数组中最长连续子序列&&环形链表的约瑟夫环问题&&树的直径

NC95 数组中最长连续子序列

题目链接

1、解题思路

首先对数组排序，然后模拟处理，类似那个最长字段和的模拟。

2、代码

import java.util.*;


public class Solution {
    /**
     * max increasing subsequence
     * @param arr int整型一维数组 the array
     * @return int整型
     */
    public int MLS (int[] arr) {
        Arrays.sort(arr);
        int ans = 1;
        int cnt = 1;
        for (int i = 1; i < arr.length; i++) {
            if (arr[i] == arr[i - 1] + 1) {
                cnt++;
            } else if (arr[i] == arr[i - 1]) {
                continue;
            } else {
                cnt = 1;
            }
            if (cnt > ans) {
                ans = cnt;
            }
        }
        return ans;
    }
}

NC132 环形链表的约瑟夫环问题

题目链接

1、解题思路

基本就是公式吧。

2、代码

import java.util.*;


public class Solution {
    /**
     * 
     * @param n int整型 
     * @param m int整型 
     * @return int整型
     */
    private int ysfHelper(int n, int m) {
        int p = 0;
        for (int i = 2; i <= n; i++) {
            p = (p + m) % i;
        }
        return p + 1;
    }

    public int ysf(int n, int m) {
        return ysfHelper(n, m);
    }
}

NC99 树的直径

题目链接

1、解题思路

首先将树转化为无向图，然后从根开始深搜，得到离根最远的那个节点p，然后再从节点p深搜，p到树的任意一个结点的最远距离就是树的直径。

2、代码

import java.util.*;

/*
 * public class Interval {
 *   int start;
 *   int end;
 * }
 */

public class Solution {
    /**
     * 树的直径
     * @param n int整型 树的节点个数
     * @param Tree_edge Interval类一维数组 树的边
     * @param Edge_value int整型一维数组 边的权值
     * @return int整型
     */
    private Map<Integer, List<Integer[]>> adjvex = new HashMap<>();// 建图 邻接表

    
    public int[] get_max_dist_node(int x, int father, int cur_dist) {
        int max_dist_ID = x;
        int max_dist = cur_dist;
        for (Integer[] tmp1 : adjvex.getOrDefault(x, new ArrayList<>())) {
            int y = tmp1[0], weight = tmp1[1];
            if (y != father) {
                int[] tmp2 = get_max_dist_node(y, x, cur_dist + weight);
                int ID = tmp2[0], dd = tmp2[1];
                if (dd > max_dist) {
                    max_dist = dd;
                    max_dist_ID = ID;
                }
            }
        }
        return new int[]{max_dist_ID, max_dist};
    }

    public int solve(int n, Interval[] Tree_edge, int[] Edge_value) {
        for (int i = 0; i < n - 1; i++) {
            int x = Tree_edge[i].start;
            int y = Tree_edge[i].end;
            int weight = Edge_value[i];
            adjvex.putIfAbsent(x, new ArrayList<>());
            adjvex.putIfAbsent(y, new ArrayList<>());
            adjvex.get(x).add(new Integer[]{y, weight});
            adjvex.get(y).add(new Integer[]{x, weight});
        }
        int[] temp1 = get_max_dist_node(0, -1, 0);
        int ID1 = temp1[0];
        int[] temp2 = get_max_dist_node(ID1, -1, 0);
        return temp2[1];
    }
}