LeetCode

LeetCode收纳箱

慢慢整理吧好乱好乱

剪绳子乘积最大

public class Solution {
    public int cutRope(int target) {
    //几种方法：
    //1. 递归：第一（i）剪最大值f(n)=max(f(i)*f(n-i))//重复计算
    //2.动态规划DP；反向递归，从下往上，从f(i),f(2)往上推
    //3.贪婪（总结规律）：
     /*4 ： 2*2
     * 5 ： 2*3
     * 6 ： 3*3
     * 7 ： 2*2*3 或者4*3
     * 8 ： 2*3*3
     * 9 ： 3*3*3
     * 10：2*2*3*3 或者4*3*3
     * 11：2*3*3*3
     * 12：3*3*3*3
     * 13：2*2*3*3*3 或者4*3*3*3
     1）最小元素是2和3，4是<2*2，5是<2*3，再往上肯定要再细分成2和3的组合
     2）首先尽可能的多留3（3>2*1）【】，并且要至少留出来一个3（只是我个人分析需要没算法并不需要）再细分要不要再拆分
     3）转折点是4和5：对3求雨，每个数都能保证包含（大于）一个3：
         若余数是0，当然全部是3；
         若余数是1，那么此时就要比较3+1<2*2(4)，就要把这个3 和余数1变成2*2，即有2个2；
         若余数是2，此时是3*2>2*2*1(5),那么保留一个2
     */
        if(target == 2)
            return 1;
        if(target == 3)
            return 2;
        
        int three = target / 3;
        int two = target % 3;
        if(two == 0)
            return (int)Math.pow(3,three);
        if(two == 1)
            return (int)Math.pow(3,three-1)*2*2;
        else
            return (int)Math.pow(3,three)*2;
        

    }
}

4. 两个排序数组的中位数

  要求复杂度O(log(M+N))

class Solution {
    public double findMedianSortedArrays(int[] A, int[] B) {
        //复杂度log（m+n）
        //依次将两数组切割成左右两半，每半个数可以有0~len个数，并混合成大的两半
        //需要满足条件：max(left)< min(right)
        //当左边小时，就增加i；左边大就减小i(折半变化)
        int m = A.length;
        int n = B.length;
        if (m > n) { // to ensure m<=n以防j为负数
            int[] temp = A; A = B; B = temp;
            int tmp = m; m = n; n = tmp;
        }
        int iMin = 0, iMax = m, halfLen = (m + n + 1) / 2;
        while (iMin <= iMax) {
            int i = (iMin + iMax) / 2;
            int j = halfLen - i; //保证混合后的两边数量都为整体的一半
            if (i < iMax && B[j-1] > A[i]){
                iMin = i + 1; // i is too small
            }
            else if (i > iMin && A[i-1] > B[j]) {
                iMax = i - 1; // i is too big
            }
            else { // i is perfect
                int maxLeft = 0;
                if (i == 0) { maxLeft = B[j-1]; }
                else if (j == 0) { maxLeft = A[i-1]; }
                else { maxLeft = Math.max(A[i-1], B[j-1]); }
                if ( (m + n) % 2 == 1 ) { return maxLeft; }

                int minRight = 0;
                if (i == m) { minRight = B[j]; }
                else if (j == n) { minRight = A[i]; }
                else { minRight = Math.min(B[j], A[i]); }

                return (maxLeft + minRight) / 2.0;
            }
        }
        return 0.0;
    }
}

29.两数相除

  给定两个整数，被除数 dividend 和除数 divisor。将两数相除，要求不使用乘法、除法和 mod 运算符。