leetcode 每天一道困难

只会用傻功夫，就下傻功夫，反正闲着也是闲着，总不能真的活着就为了死吧

leetcode 4

方法一：逐步排除法
这种方法的关键在于将问题从寻找中位数转换到 寻找第k大的元素
//审题应该是二分查找
func findMedianSortedArrays2(nums1 []int, nums2 []int) float64 {
	l1, l2 := len(nums1), len(nums2)
	tl := l1 + l2
	if tl%2 == 1 {
		t := float64(findTheKthElement(nums1, nums2, tl/2+1))
		fmt.Printf("find k:%f\n", t)
		return t
	} else {
		t1 := float64(findTheKthElement(nums1, nums2, tl/2))
		t2 := float64(findTheKthElement(nums1, nums2, tl/2+1))
		fmt.Printf("find k:%f\n", t1)
		fmt.Printf("find k:%f\n", t2)
		return (t1 + t2) / 2
	}
}

/* 主要思路：要找到第 k (k>1) 小的元素，那么就取 pivot1 = nums1[k/2-1] 和 pivot2 = nums2[k/2-1] 进行比较
 * 这里的 "/" 表示整除
 * nums1 中小于等于 pivot1 的元素有 nums1[0 .. k/2-2] 共计 k/2-1 个
 * nums2 中小于等于 pivot2 的元素有 nums2[0 .. k/2-2] 共计 k/2-1 个
 * 取 pivot = min(pivot1, pivot2)，两个数组中小于等于 pivot 的元素共计不会超过 (k/2-1) + (k/2-1) <= k-2 个
 * 这样 pivot 本身最大也只能是第 k-1 小的元素
 * 如果 pivot = pivot1，那么 nums1[0 .. k/2-1] 都不可能是第 k 小的元素。把这些元素全部 "删除"，剩下的作为新的 nums1 数组
 * 如果 pivot = pivot2，那么 nums2[0 .. k/2-1] 都不可能是第 k 小的元素。把这些元素全部 "删除"，剩下的作为新的 nums2 数组
 * 由于我们 "删除" 了一些元素（这些元素都比第 k 小的元素要小），因此需要修改 k 的值，减去删除的数的个数
 */
func findTheKthElement(nums1 []int, nums2 []int, k int) int {
	index1, index2, length1, length2 := 0, 0, len(nums1), len(nums2)
	for true {
		//特殊情况，如果数组为空，则返回另外一个数组的第k大
		if index1 == length1 {
			return nums2[index2+k-1]
		}
		if index2 == length2 {
			return nums1[index1+k-1]
		}
		//如果k=1 ，则只需要返回两个数组中更小的元素就行
		if k == 1 {
			return min(nums1[index1], nums2[index2])
		}
		half := k / 2
		newIndex1 := min(index1+half, length1) - 1
		newIndex2 := min(index2+half, length2) - 1
		pivot1, pivot2 := nums1[newIndex1], nums2[newIndex2]
		if pivot1 <= pivot2 {
			k -= (newIndex1 - index1 + 1)
			index1 = newIndex1 + 1
		} else {
			k -= (newIndex2 - index2 + 1)
			index2 = newIndex2 + 1
		}
	}
	return 0
}

func min(x, y int) int {
	if x < y {
		return x
	}
	return y
}

leetcode 312

 public static int maxCoins(int[] nums) {
        int[] n = new int[nums.length + 2];
        for (int i = 0; i < nums.length; i++) n[i + 1] = nums[i];
        n[0] = n[nums.length + 1] = 1;

        int N = nums.length + 2;
        int[][] dp = new int[N][N];
        for (int i = 0; i < N; i++) {
            dp[i][i] = n[i];
        }

        for (int left = N - 1; left >= 0; left--) {
            for (int right = left + 2; right < N; right++) {
                for (int k = left + 1; k < right; k++) {
                    int sum = n[left] * n[k] * n[right];
                    sum += (dp[left][k] + dp[k][right]);
                    dp[left][right] = Math.max(dp[left][right], sum);
                }
            }
        }
        return dp[0][N - 1];
    }