QOJ.ac

QOJ

ID题目提交者结果用时内存语言文件大小提交时间测评时间
#55775#1972. JJ RallySa3tElSefr#TL 45ms233052kbC++233.7kb2022-10-15 01:44:582022-10-15 01:45:01

Judging History

你现在查看的是最新测评结果

  • [2023-08-10 23:21:45]
  • System Update: QOJ starts to keep a history of the judgings of all the submissions.
  • [2022-10-15 01:45:01]
  • 评测
  • 测评结果:TL
  • 用时:45ms
  • 内存:233052kb
  • [2022-10-15 01:44:58]
  • 提交

answer

#include <iostream>
#include <iomanip>
#include <cstdio>
#include <cstdlib>
#include <algorithm>
#include <cmath>
#include <vector>
#include <set>
#include <map>
#include <stack>
#include <unordered_set>
#include <unordered_map>
#include <queue>
#include <ctime>
#include <cassert>
#include <complex>
#include <string>
#include <cstring>
#include <chrono>
#include <random>
#include <bitset>
#include <array>

#define ll long long
#define ld  double
using namespace std;

const int N = 500 + 5, M = (1 << 20), mod = 998244353;


int dp[M + 5][25][2];
ll f[M + 5];


int n, mp[30], s1, s2, t1, t2, cnt[M + 5], dis[30][30], Edge[30][30];
vector<int> bitsOfMask[M + 5];

int solve(int mask, int last, bool t) {
    int lastNode = mp[last], target = t1;
    if(t == 1) target = t2;
    if(cnt[mask] == 0) {
        if(dis[lastNode][target] == Edge[lastNode][target]) return 1;
        return 0;
    }
    if(dp[mask][last][t] != -1) return dp[mask][last][t];

    int ans = 0;

    for (auto &bit : bitsOfMask[mask]) {
        int curNode = mp[bit];
        if(dis[lastNode][target] == Edge[lastNode][curNode] + dis[curNode][target]) {
            ans += solve(mask ^ (1 << bit), bit, t);
        }
    }
    return dp[mask][last][t] = ans;
}





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

    int m;
    cin >> n >> m;

    for(int i = 0; i < n; i++) {
        for(int j = 0; j < n; j++) {
            Edge[i][j] = dis[i][j] = mod;
        }
    }


    for(int i = 0; i < m; i++) {
        int u, v, c;
        cin >> u >> v >> c;
        u--; v--;
        dis[u][v] = dis[v][u] = Edge[u][v] = Edge[v][u] = min(dis[u][v], c);
    }

    cin >> s1 >> t1 >> s2 >> t2;
    s1--; t1--;
    s2--; t2--;

    for(int k = 0; k < n; k++) {
        for(int i = 0; i < n; i++) {
            for(int j = 0; j < n; j++) {
                dis[i][j] = min(dis[i][j], dis[i][k] + dis[k][j]);
            }
        }
    }

    for(int i = 1; i < (1 << (n - 4)); i++) {
        cnt[i] = __builtin_popcount(i);
        for(int bit = 0; bit < (n - 4); bit++) {
            if(i >> bit & 1) {
                bitsOfMask[i].push_back(bit);
            }
        }
    }

    // cout << dis[0][1] << ' ' << dis[2][3] << '\n';
    int curId = 0;
    for(int i = 0; i < n; i++) {
        if(i == s1 || i == s2 || i == t1 || i == t2) continue;
        mp[curId] = i;
        curId++;
    }
    mp[n - 4] = s1;
    mp[n - 3] = s2;
    mp[n - 2] = t1;
    mp[n - 1] = t2;

    memset(dp, -1, sizeof dp);

    for(int mask = 0; mask < (1 << (n - 4)); mask++) {
        bool found = 0;
        for(auto &bit : bitsOfMask[mask]) {
            int curNode = mp[bit];
            if(dis[s1][t1] != dis[s1][curNode] + dis[curNode][t1]) {
                found = 1;
                break;
            }
        }
        if(found) continue;
        f[mask] = solve(mask, n - 4, 0);
    }

    for(int bit = 0; bit < (n - 4); bit++) {
        for(int mask = 0; mask < (1 << (n - 4)); mask++) {
            if(mask >> bit & 1) {
                f[mask] += f[mask ^ (1 << bit)];
            }
        }
    }

    ll ans = 0;
    for(int mask = 0; mask < (1 << (n - 4)); mask++) {
        int compMask = (1 << (n - 4)) - 1 - mask;
        if(f[mask] == 0) continue;
        bool found = 0;
        for(auto &bit : bitsOfMask[mask]) {
            int curNode = mp[bit];
            if(dis[s2][t2] != dis[s2][curNode] + dis[curNode][t2]) {
                found = 1;
                break;
            }
        }
        if(found) continue;
        ans += 1ll * solve(mask, n - 3, 1) * f[compMask];
    }
    cout << ans;






    return 0;
}

详细

Test #1:

score: 100
Accepted
time: 45ms
memory: 232952kb

input:

4 4
1 2 2
2 3 1
1 3 1
3 4 1
1 2 3 4

output:

1

result:

ok single line: '1'

Test #2:

score: 0
Accepted
time: 44ms
memory: 233052kb

input:

4 3
1 2 1
2 3 1
3 4 1
1 3 2 4

output:

0

result:

ok single line: '0'

Test #3:

score: 0
Accepted
time: 32ms
memory: 232924kb

input:

6 8
1 4 1
1 3 1
4 2 1
3 2 1
1 2 2
1 5 1
5 2 1
5 6 2
1 2 6 5

output:

3

result:

ok single line: '3'

Test #4:

score: -100
Time Limit Exceeded

input:

24 276
1 2 117
1 3 36
1 4 247
1 5 150
1 6 215
1 7 232
1 8 161
1 9 209
1 10 190
1 11 4
1 12 102
1 13 281
1 14 301
1 15 32
1 16 138
1 17 114
1 18 304
1 19 141
1 20 105
1 21 64
1 22 75
1 23 23
1 24 237
2 3 153
2 4 364
2 5 267
2 6 332
2 7 349
2 8 278
2 9 326
2 10 307
2 11 113
2 12 219
2 13 398
2 14 418
...

output:


result: