围追堵截“七十二”关

1. 来自互联网的资料

在之前的代码中，无论是Python还是Java，基本在判断值相等的时候都用了“==”；但是也有刷到Java中一个判断相等的函数，.equals()；但哪一个是值相等，哪一个是对象相等，今天仔细地探究一下。

1.1 Python篇 - is or ==

1.2 Java篇 - .equals() or ==

2. 大胆求证一番

2.1 Python求证

测试环境，Python3.8，所以其实都是在判值相等？当然不是。

可以看到，如果说is是判断值相等，那么这里不应该出现False，这说明Python对常量，如3，不另外分配空间，而是直接指向一个地址；

2.2 Java求证

3. 为什么要区分

4. 什么是线性规划？

待补充SVM模型中目标函数 与 约束条件。

5. 线性规划该怎么求解？

6. ACM模式刷题

public class Solution{
		public static void main(String[] args){
				Scanner sn = new Scanner(System.in);
				int n = sn.nextInt();
				sn.nextLine();
				int[] nums = new int[n];
				for(int i=0;i<n;i++){
						nums[i] = sn.nextInt();
				}
				sn.close();

				/**
				核心代码部分
				*/
		}

}

// 快速排序，排两个数组
		private void quickSorted(int[] numsX, int[] numsY, int low, int high){

        System.out.println("I'm executing!");

        if(low>=high) return;
        int baseX = numsX[low], baseY = numsY[low];
        int i=low, j=high;
        while(i<j){

            while(numsX[j]>=baseX && i<j){
                j--;
            }

            while(numsX[i]<=baseX && i<j){
                i++;
            }

            if(i<j){

                int tempValueX = numsX[i], tempValueY = numsY[i];

                numsX[i] = numsX[j];
                numsX[j] = tempValueX;

                numsY[i] = numsX[j];
                numsY[j] = tempValueY;

            }
        }

        numsX[low] = numsX[i];
        numsX[i] = baseX;

        numsY[low] = numsY[i];
        numsY[i] = baseY;

        quickSorted(numsX, numsY, low, i-1);
        quickSorted(numsX, numsY, i+1, high);
    }

// 归并排序，比快排稳定，平均复杂度一致
public static int[] mergeSort(int[] nums, int l, int h) {

        if (l == h)
            return new int[] { nums[l] };

        int mid = l + (h - l) / 2;
        int[] leftArr = mergeSort(nums, l, mid); //左有序数组
        int[] rightArr = mergeSort(nums, mid + 1, h); //右有序数组
        int[] newNum = new int[leftArr.length + rightArr.length]; //新有序数组

        int m = 0, i = 0, j = 0;
        while (i < leftArr.length && j < rightArr.length) {
            newNum[m++] = leftArr[i] < rightArr[j] ? leftArr[i++] : rightArr[j++];
        }
        while (i < leftArr.length)
            newNum[m++] = leftArr[i++];
        while (j < rightArr.length)
            newNum[m++] = rightArr[j++];
        return newNum;
    }

private int[] merge(int[] left, int[] right){
        // 结果数组
        int i=0;
        int[] result = new int[left.length + right.length];
        // 循环获取两个数组之间最小的数值
        while(left.length>0 && right.length>0){
            if(left[0] <= right[0]){
                result[i++] = left[0];
                left = Arrays.copyOfRange(left, 1, left.length);
            }else{
                result[i++] = right[0];
                right = Arrays.copyOfRange(right, 1, right.length);
            }
        }
        // 填充剩下的所有数据
        while(left.length>0){
            result[i++] = left[0];
            left = Arrays.copyOfRange(left, 1, left.length);
        }
        while(right.length>0){
            result[i++] = right[0];
            right = Arrays.copyOfRange(right, 1, right.length);
        }
        // 返回结果
        return result;
    }

后续