【算法训练营】象棋，序列计数（python，c++实现）

象棋

---

描述

你有足够多的象棋“车”，在一个n×n的棋盘上你能放多少个“车”呢？注意，所给棋盘上有些位置不能放任何东西。同时，某一行（列）最多只能存在一个“车”。

输入

第一行为一个正整数n。

接下来n行，每行包含n个整数，若为0表示这个位置不能放“车”；若为1表示这个位置可以放“车”。

输出

输出一个整数，表示最多能放多少个“车”。

样例1输入

5
1 0 0 0 0
0 0 0 0 0
0 0 0 1 0
1 1 0 1 0
0 0 0 1 0

样例1输出

3

样例1解释

我们这样放就只能放2个“车”：

车 0 0 0 0
0 0 0 0 0
0 0 0 1 0
1 1 0 车 0
0 0 0 1 0

若我们这样放就能放下3个了：

车 0 0 0 0
0 0 0 0 0
0 0 0 1 0
1 车 0 1 0
0 0 0 车 0

限制

对于30%的数据，n ≤ 5；

对于60%的数据，n ≤ 20；

对于100%的数据，n ≤ 500。

时间：2 sec

空间：256 MB

提示

[将横坐标和纵坐标看做是二分图的X集和Y集，会了吗？]

代码实现

def max_cars(n, board):
    def find_path(i):
        for j in range(n):
            if board[i][j] == 1 and not visited[j]:
                visited[j] = True
                if match[j] == -1 or find_path(match[j]):
                    match[j] = i
                    return True
        return False

    match = [-1] * n
    result = 0

    for i in range(n):
        visited = [False] * n
        if find_path(i):
            result += 1

    return result

# 读取输入
n = int(input())
board = []
for _ in range(n):
    row = list(map(int, input().split()))
    board.append(row)

# 计算最多能放多少个车
max_cars_count = max_cars(n, board)

# 输出结果
print(max_cars_count)

序列计数

---

描述

给定一个n个整数的序列以及一个非负整数d，请你输出这个序列中有多少个连续子序列（长度大于1），满足该子序列的最大值最小值之差不大于d。

连续子序列：序列1 2 3中长度大于1的连续子序列有：

1 2
2 3
1 2 3

输入

第一行包含两个整数n,d。

接下来一行包含n个整数。

输出

输出一个整数，表示满足条件的连续子序列个数。

样例1输入

8 5
5 5 4 8 -10 10 0 1

样例1输出

7

样例1解释

满足条件的连续子序列有：

5 5
5 5 4
5 5 4 8
5 4
5 4 8
4 8
0 1

限制

对于60%的数据，n ≤ 5000；

对于100%的数据，n ≤ 300000。

保证所有整数的绝对值不超过10^9，d不超过2×10^9。

时间：10 sec

空间：512 MB

提示

[考虑分治。]

[令函数solve(l, r)表示统计[l, r]中合法的连续子序列个数，mid为(l+r)/2（下取整），那么]

[solve(l, r) = 0, 当l = r]

[solve(l, r) = solve(l, mid) + solve(mid + 1, r) + cal(l, r, mid)，当l≠r]

[其中cal(l, r, mid)表示在左端点在区间[l, mid]中、右端点在区间[mid + 1, r]中的符合要求的连续子序列数目]

[那么答案就是solve(1, n)。]

[至于cal(l, r, mid)怎么算，大家可以仔细思考思考。（右端点是有单调性的）]

[**注意答案要用long long**]

[（另外这题也可以用线性的方法做哦~有兴趣去搜一搜单调队列，具体就是用两个单调队列分别维护最大值和最小值）]

代码实现

#include 
using namespace std;
// ================= 代码实现开始 =================
const int N = 300005;
//max_value:用于存储solve函数中的前缀最大值
//min_value:用于存储solve函数中的前缀最小值
int n, d,  max_value[N], min_value[N];
vector a;
//分治计算区间[l,r]中有多少个连续子序列满足最大值最小值之差不小于d
//l:区间左边界
//r：区间右边界
//返回值：满足条件的连续子序列的个数
long long solve(int l,int r){
    if(l==r)
        return 0;
    int mid = (l+r)>>1;//中点
    long long ans = solve(l,mid)+solve(mid+1,r); //分治求出左右两半的值
    //我们计算区间[mid+1,r]的前缀最小值，也就是说min_value = mid(a[mid+1...i]),max_value同理
    for(int i = mid+1; i<=r; ++i){
        min_value[i] = (i == mid+1)?a[i]:min(min_value[i-1],a[i]);
        max_value[i] = (i == mid+1)?a[i]:max(max_value[i-1],a[i]);
    }
    //我们倒序枚举子序列的左端点i，i的取值范围在[1,mid]
    //pos表示若连续子序列的左端点是i，那么子序列的右端点最远能拓展到pos位置，当然pos取值范围在[mid+1,r],一开始初始化为r
    //mn是后缀最小值，mx是后缀最大值，那也就是说mn=min(a[i...mid]),mx同理
    //那么以i为左端点的连续子序列（右端点在[mid+1,r]内）个数应该优pos-mid个
    int mn = 0,mx = 0, pos = r;
    for(int i=mid; i>=l && pos > mid; --i){
        //更新mn和mx
        mn = (i==mid)?a[i]:min(mn,a[i]);
        mx = (i==mid)?a[i]:max(mx,a[i]);
        for(; pos>mid && max(mx, max_value[pos])-min(mn, min_value[pos]) > d; --pos);
        ans += pos - mid; //更新答案
    }
    return ans;
}
// 求出有多少个a数组中的连续子序列（长度大于1），满足该子序列的最大值最小值之差不大于d
// n：a数组的长度
// d：所给d
// a：数组a，长度为n
// 返回值：满足条件的连续子序列的个数
long long getAnswer(int n, int d, vector a) {
    //复制到全局变量中
    ::n = n;
    ::d = d;
    ::a = a;
    return solve(0,n-1);
}
// ================= 代码实现结束 =================


int main() {
    int n, d;
    scanf("%d%d", &n, &d);
    vector a;
    a.resize(n);
    for (int i = 0; i < n; ++i)
        scanf("%d", &a[i]);
    printf("%lld\n", getAnswer(n, d, a));
    return 0;
}