Leetcode1460，源状态到目标状态，判是否可达

Leetcode1460

源状态到目标状态，判是否可达

本题转化成判断两数组元素所分别构成的两个集合是否相等
对数组中的元素进行特定的操作，判断能否达到目标状态。这是一类经典题目。不过当前这个Leetcode1460比较简单。

简单证明

因为相邻两个元素属于子数组，冒泡排序的过程就涉及相邻两个元素构成的子数组的翻转。所以，如果两个数组arr和target分别进行冒泡排序且能得到同样的升序（或降序）序列，那么对target数组进行刚才冒泡排序过程中的逆操作，这个target数组又能回到一开始的初始状态了。所以两个数组arr和target冒泡排序得到的序列相同，则表明通过翻转子数组可从arr到target。

Naive 的解法，建两个桶

bool canBeEqual(int* target, int targetSize, int* arr, int arrSize){
    if(targetSize != arrSize)return false;
    int ans = true;
    int* Tong1 = (int *)malloc(1001*sizeof(int));
    int* Tong2 = (int *)malloc(1001*(sizeof(int)));
    for(int i=0;i<1001;i++){
        Tong1[i]=0;
        Tong2[i]=0;
    }
    for(int i=0;i<targetSize;i++){
        Tong1[target[i]]++;
        Tong2[arr[i]]++;
    }
    for(int i=0;i<1001;i++){
        if(Tong1[i]!=Tong2[i]){
            ans = false;
            break;
        }
    }
    free(Tong1);
    free(Tong2);
    return ans;
}

建一个桶

bool canBeEqual(int* target, int targetSize, int* arr, int arrSize){
    if(targetSize != arrSize)return false;
    int ans = true;
    int* Tong1 = (int *)malloc(1001*sizeof(int));
//    int* Tong2 = (int *)malloc(1001*(sizeof(int)));
    for(int i=0;i<1001;i++){
        Tong1[i]=0;
//        Tong2[i]=0;
    }
    for(int i=0;i<targetSize;i++){
        Tong1[target[i]]++;
        Tong1[arr[i]]--;
    }
    for(int i=0;i<1001;i++){
        if(Tong1[i]!=0){
            ans = false;
            break;
        }
    }
    free(Tong1);
//    free(Tong2);
    return ans;
}

两种测评结果对比

红框是建一个桶的，蓝色框是建两个桶的。

感觉

双100%真爽