2021牛客多校3

F-24dian（搜索）

题意：

规则就是 $24$ 点的规则，但是本题牌数是 $1-4$ ，并且要保证在一组牌得到 $24$ 点的所有可能解中，都包含不能整除的分数。 最后求合法解数。

思路：

牌数 $\le 3$ 时，是无解的（肯定存在 不包含的分数 的解）虽然不明白，但是我再次大受震撼

直接搜索，$dfs(\text{集合}a,\text{数字}b)$ 表示是集合 $a$ 是否能凑出数字 $b$

每次从集合中取出两个数进行操作后，将结果放到集合中递归下去。

要注意，对一组牌，要求该牌所有可以凑出 24 点 的解中，都要包含不可整除的分数，该组牌才算一组合法解

代码：

#include<bits/stdc++.h>

using namespace std;

const int N = 1e5 + 10;
const double eps = 1e-9;

int n, m;
vector<int> ans[N];
int cnt = 0;
vector<double> now;

int dcmp(double x) {
    if (fabs(x) < eps) return 0;
    return x > 0 ? 1 : -1;
}

int divise(double x, double y) {  // 整除返回 0，否则返回 1
    if (dcmp(fabs(x / y - floor(x / y + 1e-8))) == 0) return 0;
    return 1;
}

int cc = 0;
int check(vector<double> nw, int b, int flag) {
    if (nw.size() == 1) {
//            printf("\n");
        double num = nw[0];
        int staus = dcmp(num - b * 1.0);
//        if (staus == 0) {
            if (cc <= 10000)
//                cout << nw[0] << " " << flag << "\n", cc++;
//        }
//        cout << num << " " << flag << " " << staus << "\n";
        if (staus == 0 && flag) return 1;  // 在答案中出现了分数
        if (staus == 0) return 2;   // 可以得到答案，但是包括分数
        return 0;
    }
    int sz = nw.size();
    // 枚举当前集合中的两个数
    int f = 0;
    for (int i = 0; i < sz; i++) {
        for (int j = i + 1; j < sz; j++) {
            double x = nw[i];
            double y = nw[j];
            double tmp;
            int staus;
            vector<double> tp;
            for (int k = 0; k < sz; k++) {
                if (k == i || k == j) continue;
                tp.push_back(nw[k]);
            }

//            printf("%.2f %.2f => +   ", x, y);
            tmp = x + y;
            tp.push_back(tmp);
            staus = check(tp, b, flag);
            if (staus == 2) return 2;
            f = max(f, staus);
            tp.pop_back();

//            printf("%.2f %.2f => -1   ", x, y);
//            if (nw.size() == 3) {
//                cout << x << " " << y << "--- 1111\n";
            tmp = x - y;
            tp.push_back(tmp);
            staus = check(tp, b, flag);
            if (staus == 2) return 2;
            f = max(f, staus);
            tp.pop_back();

//            printf("%.2f %.2f => -2   ", x, y);
//                cout << x << " " << y << "----2222\n";
            tmp = y - x;
            tp.push_back(tmp);
            staus = check(tp, b, flag);
            if (staus == 2) return 2;
            f = max(f, staus);
            tp.pop_back();
//            }

//            printf("%.2f %.2f => *   ", x, y);
            tmp = x * y;
            tp.push_back(tmp);
            staus = check(tp, b, flag);
            if (staus == 2) return 2;
            f = max(f, staus);
            tp.pop_back();


//            if (nw.size() == 4 || nw.size() == 2) {
                // 除法
            if (dcmp(y) != 0) {
//                printf("%.2f %.2f => /1   ", x, y);
//                cout << x << " " << y << "----33333\n";
                tmp = x / y;
                tp.push_back(tmp);
                staus = check(tp, b, max(flag, divise(x, y)));
                if (staus == 2) return 2;
                f = max(f, staus);
                tp.pop_back();
            }

            // 除法
            if (dcmp(x) != 0) {
//                printf("%.2f %.2f => /2   ", x, y);
//                    cout << y << " " << x << "----44444\n";
                    tmp = y / x;
                    tp.push_back(tmp);
                    staus = check(tp, b, max(flag, divise(y, x)));
                    if (staus == 2) return 2;
                    f = max(f, staus);
                    tp.pop_back();

            }
//            }
        }
    }
    return f;
}

void dfs(int d, int las) {
    if (d == n) {
//        if (now[0] == 1 && now[1] == 3 && now[2] == 4 && now[3] == 6) {
            if (check(now, m, 0) == 1) {
                cnt++;
    //            cout << "dscnjesf\n";
                for (int i = 0; i < n; i++)
                    ans[cnt].push_back(now[i]);
            }
            return;
//        }
//        return;
    }
    for (int i = las; i <= 13; i++) {
        now.push_back(i);
        dfs(d + 1, i);
        now.pop_back();
    }
}

int main() {

//    cout << divise(1.0, 2.0) << "\n";
//    cout << divise(1.9999999999, 2.0) << "\n";
//    cout << divise(2.1000000001, 2.1) << "\n";
    scanf("%d%d", &n, &m);
    if (n == 1) {
        printf("0\n");
        return 0;
    }
    else {
        cnt = 0;
        dfs(0, 1);
        printf("%d\n", cnt);
        for (int i = 1; i <= cnt; i++) {
            for (int j = 0; j < (int)ans[i].size(); j++) {
                if (j != 0) printf(" ");
                printf("%d", ans[i][j]);
            }
            printf("\n");
        }
    }
    return 0;
}

J-Counting Triangles（计数）

题意：

给定一张完全图，每条边都有一种颜色（白色|黑色），求同色三元环的个数

思路：

看到三元环，这不是板题吗，直接将无向边转为有向边来计数。然后华丽得 $T$ 了。一想复杂度，$O(m\sqrt{m})$ ，这不铁 $T$ …

正解：

因为是完全图，考虑不满同色三元环的个数，肯定是 两黑一白 或者 两白一黑 。即存在一个点连出去一黑一白两种边。

直接枚举点，统计该点连出去的白色边数 $cn{t}_1$ 和 黑色边 $cn{t}_2$，该点的贡献就是 $cn{t}_1\times cn{t}_2$。将所有点的贡献加起来，再除 $2$ （因为一个不同色三元环，由于存在两个点连出去的边是异色的，所以会被计算两次）。

代码：

#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
 
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();
    if (n < 3) {
        cout << "0\n";
        return 0;
    }
 
    ll all = 1LL * n * (n - 1) * (n - 2) / 6;
    ll del = 0;
    for (int i = 0; i < n; i++) {
        ll c0 = 0, c1 = 0;
        for (int j = 0; j < n; j++) {
            if (i == j) continue;
            if (edge[i][j]) c1++;
            else c0++;
        }
        del += c0 * c1;
    }
    del /= 2;
    all -= del;
    cout << all << "\n";
    return 0;
}