牛客：Holding Two，Inverse Pair，Counting Triangles

Holding Two

题目描述

运行代码

#include<bits/stdc++.h>
using namespace std;
const int N=3e4+5;
string s1,s2; 
int main(){
	int n,m;
	cin>>n>>m;
	for(int i=0;i<m;i++){
		if(i&1){
			s1+='0';
			s2+='1';
		} 
		else{
			s1+='1';
			s2+='0';
		} 
	}
	for(int i=0;i<n/2;i++){
		if(i&1) 
            cout<<s1<<endl<<s1<<endl;
		else 
            cout<<s2<<endl<<s2<<endl;
	}
	if(n&1){
		if((n/2)&1) 
            cout<<s1<<endl;
		else 
            cout<<s2<<endl;
	} 
	return 0;
}

代码思路

n和m：通过cin从标准输入读取两个整数，分别表示矩阵的行数和列数。
s1和s2：定义了两个string类型的变量，用于存储构建矩阵每行字符串的两种基本模式。
通过一个循环从i = 0到i < m来构建s1和s2。
当i为奇数（i & 1为真）时，s1添加字符'0'，s2添加字符'1'。
当i为偶数（i & 1为假）时，s1添加字符'1'，s2添加字符'0'。
最终s1和s2分别是长度为m的由0和1交替组成的字符串，且s1和s2的对应位不同
首先处理行数为偶数的情况（n为偶数）：
通过一个循环从i = 0到i < n / 2来构建矩阵的前n / 2行。
当i为奇数（i & 1为真）时，连续输出两次s1，即输出两行相同的由0和1组成的字符串，对应矩阵中的两行。
当i为偶数（i & 1为假）时，连续输出两次s2，对应矩阵中的另外两行。
然后处理行数为奇数的情况（n为奇数）：
通过判断(n / 2) & 1来确定最后一行输出s1还是s2。如果(n / 2)为奇数，则输出s1；如果(n / 2)为偶数，则输出s2。

Inverse Pair

题目描述

运行代码

#include <bits/stdc++.h>
using namespace std;

const int maxn = 2e5 + 5;
int a[maxn], c[maxn], n;
bool v[maxn];

int lowbit(int n) {
    return n & (-n);
}

void add(int x) {
    while (x <= n + 1) {
        c[x]++;
        x += lowbit(x);
    }
}

int ask(int x) {
    int sum = 0;
    while (x > 0) {
        sum += c[x];
        x -= lowbit(x);
    }
    return sum;
}

int main() {
    ios::sync_with_stdio(false);
    cin.tie(0);

    cin >> n;
    for (int i = 1; i <= n; i++) {
        cin >> a[i];
    }

    reverse(a + 1, a + n + 1);
    long long ans = 0;

    for (int i = 1; i <= n; i++) {
        if (!v[a[i]]) {
            a[i]++;
        }
        ans += ask(a[i] - 1);
        add(a[i]);
        v[a[i]] = true;
    }

    cout << ans << endl;
    return 0;
}

代码思路

maxn：定义了一个常量，表示数组的最大长度，用于确定数组的大小，避免数组越界。
a数组：用于存储输入的排列 $a_1...n{}$ 。
c数组：这是一个树状数组，用于辅助计算逆序对数。
n：通过输入获取，表示排列的长度。
v数组：用于标记某个数是否已经在处理过程中被使用过，是一个布尔类型的数组。
lowbit函数：用于获取一个数的二进制表示中最低位的所对应的数值。这是树状数组中常用的操作，用于快速定位和更新树状数组中的节点。
add函数：用于在树状数组中对指定位置的元素进行更新。它会从给定的位置开始，向上更新所有包含该位置的父节点，更新方式是将对应节点的值加。
ask函数：用于查询树状数组中从到指定位置的所有元素之和。它通过不断减去当前位置的lowbit值，获取到所有需要累加的节点，并返回累加的结果。

通过cin读取排列的长度，然后再读取 $a_1...n{}$ 排列的各个元素。将排列反转，这一步操作可能是为了方便后续从后往前处理排列，以便更好地利用树状数组计算逆序对数。
初始化一个变量ans为，用于累加逆序对数。从i=1到i=n遍历反转后的排列。
- 将当前元素标记为已使用（即v[a[i]]设置为true）。
- 调用add(a[i])在树状数组中更新当前元素的位置，将对应节点的值加，以便后续计算其他元素的逆序对数时使用。
- 通过ask(a[i] - 1)查询树状数组中小于当前元素的元素个数，并累加到ans中。这一步计算了当前元素与前面已经处理过的元素形成的逆序对数。
- 如果当前元素没有被标记过（即v[a[i]]为false），则将其加。这一步操作是在选择合适的，使得，通过将部分元素加来调整序列，以减少逆序对数。
输出部分：最后输出计算得到的最小逆序对数ans。

Counting Triangles

题目描述

链接：https://ac.nowcoder.com/acm/contest/90188/J
来源：牛客网

namespace GenHelper
{
    unsigned z1,z2,z3,z4,b,u;
    unsigned get()
    {
        b=((z1<<6)^z1)>>13;
        z1=((z1&4294967294U)<<18)^b;
        b=((z2<<2)^z2)>>27;
        z2=((z2&4294967288U)<<2)^b;
        b=((z3<<13)^z3)>>21;
        z3=((z3&4294967280U)<<7)^b;
        b=((z4<<3)^z4)>>12;
        z4=((z4&4294967168U)<<13)^b;
        return (z1^z2^z3^z4);
    }
    bool read() {
      while (!u) u = get();
      bool res = u & 1;
      u >>= 1; return res;
    }
    void srand(int x)
    {
        z1=x;
        z2=(~x)^0x233333333U;
        z3=x^0x1234598766U;
        z4=(~x)+51;
      	u = 0;
    }
}
using namespace GenHelper;
bool edge[8005][8005];
int main() {
  int n, seed;
  cin >> n >> seed;
  srand(seed);
  for (int i = 0; i < n; i++)
    	for (int j = i + 1; j < n; j++)
        	edge[j][i] = edge[i][j] = read();
 	return 0;
}

运行代码

#include <iostream>
#include <array>

class GenHelper {
public:
    unsigned z1, z2, z3, z4, b, u;

    unsigned get() {
        b = ((z1 << 6) ^ z1) >> 13;
        z1 = ((z1 & 4294967294U) << 18) ^ b;
        b = ((z2 << 2) ^ z2) >> 27;
        z2 = ((z2 & 4294967288U) << 2) ^ b;
        b = ((z3 << 13) ^ z3) >> 21;
        z3 = ((z3 & 4294967280U) << 7) ^ b;
        b = ((z4 << 3) ^ z4) >> 12;
        z4 = ((z4 & 4294967168U) << 13) ^ b;
        return z1 ^ z2 ^ z3 ^ z4;
    }

    bool read() {
        while (!u) u = get();
        bool res = u & 1;
        u >>= 1;
        return res;
    }

    void srand(int x) {
        z1 = x;
        z2 = (~x) ^ 0x233333333U;
        z3 = x ^ 0x1234598766U;
        z4 = (~x) + 51;
        u = 0;
    }
};

int main() {
    int n, seed;
    std::cin >> n >> seed;
    GenHelper helper;
    helper.srand(seed);
    bool edge[8005][8005] = {false};
    for (int i = 0; i < n; i++) {
        for (int j = i + 1; j < n; j++) {
            edge[j][i] = edge[i][j] = helper.read();
        }
    }

    long long ans = 0;
    for (int i = 0; i < n; i++) {
        std::array<long long, 2> cnt = {0, 0};
        for (int j = 0; j < n; j++) {
            if (i == j) continue;
            cnt[edge[i][j]]++;
        }
        ans += cnt[0] * cnt[1];
    }

    ans = 1LL * n * (n - 1) * (n - 2) / 6 - ans / 2;
    std::cout << ans << "\n";
    return 0;
}

代码思路

计算一个无向完全图中同色三角形（即三个顶点构成的三角形三条边颜色相同）的数量。通过给定顶点数量n和随机数生成器种子seed，利用特定的随机生成方式生成图的边颜色，然后计算同色三角形的数量并输出结果。

变量：
- n：表示无向完全图的顶点数量。
- seed：随机数生成器的种子。
- edge[8005][8005]：二维布尔数组，用于存储无向完全图的边颜色，edge[i][j]=1表示顶点i到顶点j的边为黑色，否则为白色。
- ans：用于存储最终的同色三角形数量。
- cnt：长度为 2 的数组，用于统计与某个顶点相连的边中黑色边和白色边的数量。
类GenHelper：
- 这个类用于生成随机数和读取随机生成的布尔值，以确定图中边的颜色。
- 成员变量：z1、z2、z3、z4、b、u：用于内部的随机数生成算法。
- 成员函数：
  - get()：通过一系列位运算生成一个随机数。
  - read()：读取一个随机生成的布尔值。如果u为 0，则调用get()生成新的随机数，然后取u的最低位作为结果，并将u右移一位。
  - srand(int x)：设置随机数生成器的种子，初始化z1、z2、z3、z4和u。
输入部分：从标准输入读取顶点数量n和随机数生成器种子seed。创建GenHelper对象helper，并使用seed调用srand方法初始化随机数生成器。
生成图的边颜色：使用两个嵌套的循环遍历图的所有边（不包括自环），对于每条边(i, j)，调用helper.read()获取一个随机布尔值，确定边的颜色，并将结果存储在edge数组中。
计算同色三角形数量：初始化变量ans为 0。
- 对于每个顶点i：
  - 创建一个长度为 2 的数组cnt，用于统计与顶点i相连的边中黑色边和白色边的数量。
  - 遍历所有顶点j（j不等于i），根据edge[i][j]的值更新cnt数组。
  - ans增加cnt[0] * cnt[1]，表示以顶点i为一个顶点的异色三角形数量。
- 最终的同色三角形数量等于总三角形数量减去异色三角形数量的一半。总三角形数量为n * (n - 1) * (n - 2) / 6，因为从n个顶点中选三个顶点的组合数为这个值。而异色三角形被计算了两次，所以要除以 2。
输出部分：输出计算得到的同色三角形数量ans。