【C++刷题】优选算法——分治

1. 颜色分类

void sortColors(vector<int>& nums)
{
    int left = -1, right = nums.size();
    for (int i = 0; i < right;) {
        if (nums[i] == 0) {
            swap(nums[++left], nums[i++]);
        } else if (nums[i] == 2) {
            swap(nums[--right], nums[i]);
        } else {
            ++i;
        }
    }
}

2. 排序数组

// 快速排序
void quick_sort(vector<int>& nums, int start, int end) {
    if (start >= end) return;

    int key = nums[rand() % (end - start + 1) + start];
    int left = start - 1, right = end + 1;
    for (int i = start; i < right;) {
        if (nums[i] < key) {
            swap(nums[++left], nums[i++]);
        } else if(nums[i] > key) {
            swap(nums[--right], nums[i]);
        } else {
            ++i;
        }
    }
    quick_sort(nums, start, left);
    quick_sort(nums, right, end);
}
vector<int> sortArray(vector<int>& nums) {
    srand(time(nullptr));
    quick_sort(nums, 0, nums.size() - 1);
    return nums;
}

// 归并排序
vector<int> tmp;
void merge_sort(vector<int>& nums, int start, int end) {
    if (start >= end) return;

    int mid = start + (end - start) / 2;
    merge_sort(nums, start, mid);
    merge_sort(nums, mid + 1, end);
    int left = start, right = mid + 1, i = start;
    while (left <= mid && right <= end) {
        if (nums[left] < nums[right]) {
            tmp[i++] = nums[left++];
        } else {
            tmp[i++] = nums[right++];
        }
    }
    while (left <= mid) {
        tmp[i++] = nums[left++];
    }
    while (right <= end) {
        tmp[i++] = nums[right++];
    }
    for (int i = start; i <= end; ++i) {
        nums[i] = tmp[i];
    }
}

vector<int> sortArray(vector<int>& nums) {
    tmp = vector<int>(nums.size());
    merge_sort(nums, 0, nums.size() - 1);
    return nums;
}

3. 数组中的第K个最大元素

void quick_sort(vector<int>& nums, int start, int end, int k) {
    if (start >= end) return;

    int key = nums[rand() % (end - start + 1) + start];
    int left = start - 1, right = end + 1;
    for (int i = start; i < right;) {
        if (nums[i] > key) {
            swap(nums[++left], nums[i++]);
        } else if(nums[i] < key) {
            swap(nums[--right], nums[i]);
        } else {
            ++i;
        }
    }
    int a = left + 1, b = right - a;
    if (a >= k) {
        quick_sort(nums, start, left, k);
    } else if (a + b >= k) {
        return;
    } else {
        quick_sort(nums, right, end, k);
    }
}
int findKthLargest(vector<int>& nums, int k) {
    srand(time(nullptr));
    quick_sort(nums, 0, nums.size() - 1, k);
    return nums[k - 1];
}

4. 库存管理 III

void quick_sort(vector<int>& stock, int start, int end, int cnt) {
    if (start >= end) return;

    int key = stock[rand() % (end - start + 1) + start];
    int left = start - 1, right = end + 1;
    for (int i = start; i < right;) {
        if (stock[i] < key) {
            swap(stock[++left], stock[i++]);
        } else if (stock[i] > key) {
            swap(stock[--right], stock[i]);
        } else {
            ++i;
        }
    }
    int a = left + 1, b = right - a;
    if (a >= cnt) {
        quick_sort(stock, start, left, cnt);
    } else if (a + b >= cnt) {
        return;
    } else {
        quick_sort(stock, right, end, cnt);
    }
}
vector<int> inventoryManagement(vector<int>& stock, int cnt) {
    srand(time(nullptr));
    quick_sort(stock, 0, stock.size() - 1, cnt);
    return vector<int>(stock.begin(), stock.begin() + cnt);
}

5. 交易逆序对的总数

int count = 0;
vector<int> tmp;
void merge_sort(vector<int>& record, int start, int end) {
    if (start >= end) return;

    int mid = start + (end - start) / 2;
    merge_sort(record, start, mid);
    merge_sort(record, mid + 1, end);
    int left = start, right = mid + 1, i = start;
    while (left <= mid && right <= end) {
        if (record[left] > record[right]) {
            tmp[i++] = record[left++];
            count += (end - right + 1); // 灵魂之解
        } else {
            tmp[i++] = record[right++];
        }
    }
    while (left <= mid) {
        tmp[i++] = record[left++];
    }
    while (right <= end) {
        tmp[i++] = record[right++];
    }
    for (int i = start; i <= end; ++i) {
        record[i] = tmp[i];
    }
}
int reversePairs(vector<int>& record) {
    tmp.resize(record.size());
    merge_sort(record, 0, record.size() - 1);
    return count;
}

6. 计算右侧小于当前元素的个数

vector<int> ret, index, tmp_index, tmp_nums;
void merge_sort(vector<int>& nums, int start, int end) {
    if (start >= end) return;

    int mid = start + (end - start) / 2;
    merge_sort(nums, start, mid);
    merge_sort(nums, mid + 1, end);

    int left = start, right = mid + 1, i = start;
    while (left <= mid && right <= end) {
        if (nums[left] > nums[right]) {
            tmp_nums[i] = nums[left];
            tmp_index[i] = index[left];
            ret[index[left]] += (end - right + 1);
            ++i;++left;
        } else {
            tmp_nums[i] = nums[right];
            tmp_index[i] = index[right];
            ++i;++right;
        }
    }
    while (left <= mid) {
        tmp_nums[i] = nums[left];
        tmp_index[i] = index[left];
        ++i;++left;
    }
    while (right <= end) {
        tmp_nums[i] = nums[right];
        tmp_index[i] = index[right];
        ++i;++right;
    }
    for (int i = start; i <= end; ++i) {
        nums[i] = tmp_nums[i];
        index[i] = tmp_index[i];
    }
}
vector<int> countSmaller(vector<int>& nums) {
    int n = nums.size();
    index.resize(n);
    for (int i = 0; i < n; ++i) {
        index[i] = i;
    }
    ret.resize(n);
    tmp_nums.resize(n);
    tmp_index.resize(n);

    merge_sort(nums, 0, nums.size() - 1);
    return ret;
}

7. 翻转对

int count = 0;
vector<int> tmp;
void merge_sort(vector<int>& nums, int start, int end) {
    if (start >= end) return;

    int mid = start + (end - start) / 2;
    merge_sort(nums, start, mid);
    merge_sort(nums, mid + 1, end);

    int left = start, right = mid + 1;
    while (left <= mid && right <= end) {
        if (nums[left] > 2 * (long long)nums[right]) {
            count += (end - right + 1);
            ++left;
        } else {
            ++right;
        }
    }
    left = start, right = mid + 1;
    int i = start;
    while (left <= mid && right <= end) {
        if (nums[left] > nums[right]) {
            tmp[i++] = nums[left++];
        } else {
            tmp[i++] = nums[right++];
        }
    }
    while (left <= mid) tmp[i++] = nums[left++];
    while (right <= end) tmp[i++] = nums[right++];

    for (int i = start; i <= end; ++i) {
        nums[i] = tmp[i];
    }
}
int reversePairs(vector<int>& nums) {
    tmp.resize(nums.size());
    merge_sort(nums, 0, nums.size() - 1);
    return count;
}