SRM 721 DIV2

  Single Round Match 721 Round 1 - Division II, Level One

代码如下：

public class FlightDataRecorder {
    public double getDistance(int[] heading, int[] distance)
    {
        double startx = 0, starty = 0;
        double dstx = 0, dsty = 0;
        for (int i = 0; i < heading.length; i++)
        {
            double radian = Math.PI * heading[i] / 180;
            dstx += distance[i] * Math.cos(radian);
            dsty += distance[i] * Math.sin(radian);
        }

        return Math.sqrt(Math.pow(startx - dstx, 2) + Math.pow(starty - dsty, 2));
    }
}

  Single Round Match 721 Round 1 - Division II, Level Two

代码如下：

public class RememberWordsEasy {
    public String isPossible(int d1, int d2, int w1, int w2)
    {
        int mod = w1 % d1;
        int leftMin = w1 / d1;
        if (mod != 0) leftMin++;

        int leftMax = 0;
        if (w1 >=d1)
            leftMax = (2 * w1 / d1 + d1 - 1) / 2;
        else
            leftMax = (w1 + 1) / 2;

        int rightMin = (2 * w2 / d2 + 1 - d2) / 2;
        if (rightMin < 0) rightMin = 0;
        int rightMax = w2 / d2;

        //System.out.println("leftMin:" + leftMin + " leftMax:" + leftMax + " rightMin:" + rightMin + " rigthMax:" + rightMax);
        if ((rightMin>= leftMin && rightMin <= leftMax) ||
                (rightMax>= leftMin && rightMax <= leftMax) ||
                (rightMin - leftMin >= 0 && rightMin - leftMin <= 1) ||
                (rightMax - leftMin >= 0 && rightMax - leftMin <= 1) ||
                (rightMax - leftMax >= 0 && rightMax - leftMax <= 1) ||
                (rightMin - leftMax >= 0 && rightMin - leftMax <= 1)) return "Possible";

        return "Impossible";
    }
}

  Single Round Match 721 Round 1 - Division II, Level Three

import java.util.*;

public class ApocalypseEasy {

    private static List<Integer>[] adjList;
    private static Set<Integer> set = new HashSet<>();
    private static Set<Integer> tokenSet = new HashSet<>();
    private static boolean flag = false;


    public int maximalSurvival(int[] p, int[] position, int t)
    {
        int n = p.length;
        adjList = new List[n + 1];
        for (int i = 0; i < n + 1; i++) {
            adjList[i] = new ArrayList<Integer>();
            tokenSet.add(i);
        }

        for (int i : position)
        {
            tokenSet.remove(i);
        }

        set.clear();
        for (int i : position)
        {
            set.add(i);
        }

        for (int i = 0; i < n; i++)
        {
            adjList[p[i]].add(i + 1);
            adjList[i + 1].add(p[i]);
        }


        int ans = 0;
        for (int u : position)
        {
            flag = false;
            boolean success = dfs(u, -1, t);
            if (success) ans++;
        }

        return ans;
    }

    private boolean dfs(int u, int p, int t)
    {
        if (t <= 0) {
            if (tokenSet.contains(u)) return true;
            return false;
        }

        for (Integer v : adjList[u]) {
            if (v == p) continue;

            if (set.contains(v)) {
                if(dfs(v, u, --t)) return true;
            } else if (tokenSet.contains(v)) {
                if (dfs(v, u, --t)) {
                    if (!flag){
                        tokenSet.remove(v);
                        flag = true;
                    }
                    return true;
                }
            }
        }

        if (tokenSet.contains(u)) return true;

        return false;
    }

}