LeetCode解题报告—— Combination Sum & Combination Sum II & Multiply Strings

1. Combination Sum

Given a set of candidate numbers (C) (without duplicates) and a target number (T), find all unique combinations in C where the candidate numbers sums to T.

The same repeated number may be chosen from C unlimited number of times.

Note:

• All numbers (including target) will be positive integers.
• The solution set must not contain duplicate combinations.

For example, given candidate set [2, 3, 6, 7] and target 7, 
A solution set is: 

[
  [7],
  [2, 2, 3]
]

解析：从一组不重复的数字中选择若干个，和为指定的数字，注意单个数字能重复选择，找出所有这种组合。一个可行的想法是利用递归的思想来解决，每当选一个值 a 后，剩下的是如何从数字组中找出和为 target-a 的组合，其实是相同的问题。

基本递归思路：保持一个“全局”的 List<List<integer>> 用于存储符合条件的数字对 ——> 保持一个临时存储遍历到的数字对的集合 tempList ——> 用一个remain来记录target减去临时数字集合后剩下的值，用一个start来记录数组递归遍历的开始位置 ——> 从数组的第一位开始递归遍历，将数字加入到临时集合中，这个时候判断 remain的正负，如果小于0表明这个值不应该加入到当前的 tempList中，直接跳出，返回到上一层递归；如果等于0，则表明当前的tempList中的数字对之和正好为target，直接加入到 List<List<integer>> 中；如果大于0则继续向下递归。

import java.util.*;

public class LeetCode{
    public static void main(String[] args){
        Scanner sc=new Scanner(System.in);
        String input=sc.nextLine().replaceAll("\\]|\\[| ","");  //这里 ] 好像一定要在 [ 的前面，要不然不能正确替换
        int target=sc.nextInt();
        String[] strs=input.split(",");
        int[] nums=new int[strs.length];
        for(int i=0;i<strs.length;i++)
            nums[i]=Integer.parseInt(strs[i]);　　//对于char可以直接减字符0转为整数但是对于String是不行的
        
        List<List<Integer>> list=new ArrayList<>();
        backtrack(list, new ArrayList<Integer>(), nums, target,0);
        for(List<Integer> i:list){
            for(int a:i)
                System.out.print(a+" ");
            System.out.println();
        }
    }
    
    public static void backtrack(List<List<Integer>> list, List<Integer> tempList,int[] nums, int remain, int start){
        if(remain<0) return;
        else if(remain==0) list.add(new ArrayList<>(tempList));　　//以tempList中的数字实例化新的List再放入到集合中，不能直接放tempList
        else{
            for(int i=start;i<nums.length;i++){
                tempList.add(nums[i]);
                backtrack(list,tempList,nums,remain-nums[i],i);　　//i不加1是因为能再选nums[i]
                tempList.remove(tempList.size()-1);
            }
        }
    }
}

关于上面学到的一点是，如果往集合里加集合，那么加入的貌似是它的引用。试了先将 List<List<integer>> 中加入一个空的List<Integer>, 之后这个List<Integer>怎么改变，原List<List<Integer>>也会改变。这也解释了为什么每次要以tempList中的数字实例化新的List再放入到集合中，而不能直接放tempList。

 

2. Combination Sum II

上面题目的一种变体，区别就是数字不能重复选择了。 

For example, given candidate set [10, 1, 2, 7, 6, 1, 5] and target 8, 

A solution set is: 

[
  [1, 7],
  [1, 2, 5],
  [2, 6],
  [1, 1, 6]
]

解法和上面的类似：

import java.util.*;

public class LeetCode{
    public static void main(String[] args){
        Scanner sc=new Scanner(System.in);
        String sc_r=sc.nextLine().replaceAll("\\]| |\\[","");
        int target=sc.nextInt();
        String[] scs=sc_r.split(",");
        int[] array=new int[scs.length];
        for(int i=0;i<scs.length;i++){
            array[i]=Integer.parseInt(scs[i]);
        }
        List<List<Integer>> res=combinationsSum2(array,target);
        for(List<Integer> list:res){
            for(int a:list)
                System.out.print(a+" ");
            System.out.println();
        }
    }
    
    static List<List<Integer>> combinationsSum2(int[] cand, int target){
        Arrays.sort(cand);
        List<List<Integer>> res=new ArrayList<List<Integer>>();
        List<Integer> path=new ArrayList<Integer>();
        dfs_com(cand,0,target,path,res);
        return res;
    }
    
    static void dfs_com(int[] cand, int cur, int target, List<Integer> path, List<List<Integer>> res){
        if(target==0){
            res.add(new ArrayList(path));
            return;
        }
        if(target<0)return;
        for(int i=cur;i<cand.length;i++){
            if(i>cur&&cand[i]==cand[i-1]) continue;
            path.add(path.size(),cand[i]);
            dfs_com(cand,i+1,target-cand[i],path,res);
            path.remove(path.size()-1);
        }
    }
}

 

3. Multiply Strings

Given two non-negative integers num1 and num2 represented as strings, return the product of num1 and num2.

Note:

1. The length of both num1 and num2 is < 110.
2. Both num1 and num2 contains only digits 0-9.
3. Both num1 and num2 does not contain any leading zero.
4. You must not use any built-in BigInteger library or convert the inputs to integer directly.

思路：这题的要求很明显，就是对字符串形式的两个数字，不实用内置的字符串转整数方法来实现两者之间的乘法。基本思路是现将字符串转为数字数组，再观察下乘法的规律，当然了，涉及到数组，那么就要找到单个数字乘法与数组索引之间的规律。一个重点是：

Start from right to left, perform multiplication on every pair of digits, and add them together. Let’s draw the process! From the following draft, we can immediately conclude:

 num1[i] * num2[j] will be placed at indices [i + j, i + j + 1] 

找到了这个规律，那么便可以使用两层循环来实现乘法，数字和数字相乘时，和应该是乘积加上一轮循环计算中得到的相应位置低位值，然后分别利用除法和取余来更新高位和低位的数字，注意这里高位还要加上原有位置计算得到的值。

import java.util.*;

public class LeetCode{
    public static void main(String[] args){
        Scanner sc=new Scanner(System.in);
        String num1=sc.nextLine();
        String num2=sc.nextLine();
        System.out.println(multiply(num1,num2));
    }
    
    static String multiply(String num1, String num2){
        int m=num1.length(),n=num2.length();
        int[] pos=new int[m+n];
        
        for(int i=m-1;i>=0;i--){
            for(int j=n-1;j>=0;j--){
                int mul=(num1.charAt(i)-'0')*(num2.charAt(j)-'0');
                int p1=i+j,p2=i+j+1;
                int sum=mul+pos[p2];
                
                pos[p1]+=sum/10;　　//高位是除法后加上上一次循环时得到的高位的值
                pos[p2]=sum%10;　　 //低位直接取余
            }
        }
        
　　　// 将pos数组转为字符创，不要前面的0
        StringBuilder sb=new StringBuilder();
        for(int p:pos)if(!(sb.length()==0&&p==0)) sb.append(p);　　//去除pos数组中前面的0，一开始当sb中没有值并且遇到的是数组中前面的0时，不将数字放入到sb中
        return sb.length()==0? "0":sb.toString();
    }
}