【LeetCode】LeetCode中那些应该背下来的经典代码

53. Maximum Subarray

问题描述

问题链接：https://leetcode.com/problems/maximum-subarray/#/description

Find the contiguous subarray within an array (containing at least one number) which has the largest sum.

For example, given the array [-2,1,-3,4,-1,2,1,-5,4],
the contiguous subarray [4,-1,2,1] has the largest sum = 6.

经典解法

public static int maxSubArray(int[] A) {
    int maxSoFar=A[0], maxEndingHere=A[0];
    for (int i=1;i<A.length;++i){
        maxEndingHere= Math.max(maxEndingHere+A[i],A[i]);
        maxSoFar=Math.max(maxSoFar, maxEndingHere); 
    }
    return maxSoFar;
}

136. Single Number中使用异或求解

问题描述

问题链接：https://leetcode.com/problems/single-number/#/description

Given an array of integers, every element appears twice except for one. Find that single one.

Note:

Your algorithm should have a linear runtime complexity. Could you implement it without using extra memory?

经典解法

known that A XOR A = 0 and the XOR operator is commutative, the solution will be very straightforward.

int singleNumber(int A[], int n) {
    int result = 0;
    for (int i = 0; i<n; i++)
    {
        result ^=A[i];
    }
    return result;
}

526. Beautiful Arrangement中回溯法求解

问题描述

问题链接：https://leetcode.com/problems/beautiful-arrangement/#/description

Suppose you have N integers from 1 to N. We define a beautiful arrangement as an array that is constructed by these N numbers successfully if one of the following is true for the ith position (1 ≤ i ≤ N) in this array:

1. The number at the ith position is divisible by i.
2. i is divisible by the number at the ith position.

Now given N, how many beautiful arrangements can you construct?

Example 1:

Input: 2
Output: 2
Explanation: 

The first beautiful arrangement is [1, 2]:

Number at the 1st position (i=1) is 1, and 1 is divisible by i (i=1).

Number at the 2nd position (i=2) is 2, and 2 is divisible by i (i=2).

The second beautiful arrangement is [2, 1]:

Number at the 1st position (i=1) is 2, and 2 is divisible by i (i=1).

Number at the 2nd position (i=2) is 1, and i (i=2) is divisible by 1.

Note:

N is a positive integer and will not exceed 15.

经典解法

public class Solution {

    private int count = 0;

    public int countArrangement(int N) {
        /*
        思路是使用回溯法。如果当前的解满足要求，就继续向下走去探索子节点，否则就返回
        是一种优秀的剪枝算法
        */
        int[] nums = new int[N + 1];
        for(int i = 1; i <= N; i++){
            nums[i] = i;
        }
        backTracking(nums,1);
        return count;
    }

    private void backTracking(int[] nums, int start){
        if(start >= nums.length){
            count++;  // 找到一个解
            return;
        }

        for(int i = start; i < nums.length; i++){
            swap(nums,i,start);
            if(nums[start] % start == 0 || start % nums[start] == 0){ // 子节点可能有解
                backTracking(nums,start + 1);
            }
            swap(nums,start,i);
        }
    }

    private void swap(int[] nums, int from, int to){
        int temp = nums[from];
        nums[from] = nums[to];
        nums[to] = temp;
    }
}

【LeetCode】357. Count Numbers with Unique Digits

问题描述

问题链接：https://leetcode.com/problems/count-numbers-with-unique-digits/#/description

Given a non-negative integer n, count all numbers with unique digits, x, where 0 ≤ x < 10n.

Example:

Given n = 2, return 91. (The answer should be the total numbers in the range of 0 ≤ x < 100, excluding [11,22,33,44,55,66,77,88,99])

Hint:

A direct way is to use the backtracking approach.

经典代码

Thanks for sharing. I think it could be simplified further. This problem is kind of like permutation + subset, so we start from 0 every recursion and count through the path. Forgive me if anything unclear, here is the code:

public class Solution {
    public int countNumbersWithUniqueDigits(int n) {
        return doCount(n, new boolean[10], 0);
    }

    private int doCount(int n, boolean[] used, int d) {
        if (d == n) return 1;
        int total = 1;
        for (int i = (d == 0) ? 1 : 0; i <= 9; i++) {
            if (!used[i]) {
                used[i] = true;
                total += doCount(n, used, d + 1);
                used[i] = false;
            }
        }
        return total;
    }
}