105. 从前序与中序遍历序列构造二叉树

解题思路：

通过先序遍历可以确定根节点，然后拿着这个根节点去中序遍历查看位置，在这个位置左边的都是节点左子树上的值，右边的都是节点右子树上的值。当前节点的左节点就是当前节点在前序遍历中位置的下一个，右节点就是  当前节点在前序遍历中位置+左节点的个数+1 .

最后使用一个区间保存这个节点的子树的个数，当这个区间中什么节点都没有的时候就可以返回。

代码：

class Solution {
     HashMap<Integer,Integer> hashMap=new HashMap<>();
    public  TreeNode buildTree(int[] preorder, int[] inorder) {
        for (int i = 0; i < inorder.length; i++) {
            hashMap.put(inorder[i],i);
        }
        return Tree(preorder,0,preorder.length-1,0);
    }
    public  TreeNode Tree(int[] preorder,int l,int r,int k){
        if(r<l){
            return null;
        }
        TreeNode root=new TreeNode(preorder[k]);
        int t=hashMap.get(root.val);
        root.left=Tree(preorder,l,t-1,k+1);
        root.right=Tree(preorder,t+1,r,k+1+(t-l));
        return root;
    }
}

437. 路径总和 III

解题思路：

暴力法：以每一个节点为起点进行扫描，如果这个节点下有路径的和为targetSum，那么就记录+1。

代码：

class Solution {
    public int pathSum(TreeNode root, int targetSum) {
        if (root == null) {
            return 0;
        }
        return check(root, targetSum,0) + pathSum(root.left, targetSum) + pathSum(root.right, targetSum);
    }

    public int check(TreeNode root, int k,long sum) {
        if(root==null){
            return 0;
        }
        sum+=root.val;
        int t=0;
        if(sum==k){
            t=1;
        }
        return t+check(root.left,k,sum)+check(root.right,k,sum);
    }
}

A. Two Frogs

解题思路：可以看出两个青蛙之间，当他们碰面时双方便会只有一个位置可以踏出，此时一方只能后退，后退者必输。所以只需要看谁先踏出后退的那一脚就好，也就是判断一下他们之间的距离。

代码：

import java.util.*;
public class LuoGu {
    public static void main(String[] args) {
        Scanner sc=new Scanner(System.in);
        int n=sc.nextInt();
        int x,y;
        for (int i = 0; i < n; i++) {
            int sum=sc.nextInt();
            x=sc.nextInt();
            y=sc.nextInt();
            int l=x+y-1;
            if(l%2==0){
                System.out.println("no");
            }else{
                System.out.println("yes");
            }
        }
    }
}

B. Crafting

解题思路：

仔细读题便可以发现如果有两个需要补的材料，那么一方补上会使另一方无法补全，所以只能有一个材料缺失。

当只有一个材料缺失的时候，其它的材料能否补全这个材料呢？接下来只要判断多余的材料能否补全便可。

代码：

import java.util.*;

public class LuoGu {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int m = sc.nextInt();
        int[] g = new int[200100];
        int[] j = new int[200100];
        for (int i = 0; i < m; i++) {
            int n = sc.nextInt();
            for (int x = 0; x < n; x++) {
                g[x] = sc.nextInt();
            }
            int sum = 0;
            int max = 0;
            int min = Integer.MAX_VALUE;
            for (int x = 0; x < n; x++) {
                j[x] = sc.nextInt();
                if (g[x] < j[x]) {
                    sum++;
                    max = j[x] - g[x];
                }
                if (g[x] >= j[x] && (min == -1 || min > g[x] - j[x])) {
                    min = g[x] - j[x];
                }
            }
            if (sum == 0 || sum == 1 && max <= Math.abs(min)) {
                System.out.println("yes");
            } else {
                System.out.println("no");
            }
        }
    }
}