洛谷P2668 斗地主

好，终于搞完了这一道毒瘤题......

先想到搜索，然后想到状压，发现数据组数很多，又是随机，还是决定用搜索。

先搜出的多的，于是顺序是三个顺子，然后按照多到少搜带牌，最后是不带牌。

大体思路很简单，写起来很毒瘤...

注意很多细节...我就是一个地方没写上界导致数组越界了。

---

三带一别带自己，因为可以算在4不带里。

王可以当对子出，当单牌带，但是不能当对牌带。

4带2对是存在的。

王的读入是0 1和0 2，中间有空格...

函数调用我写的很多，复制粘贴时别写混了。

变量++找牌的时候，要规定上界。

---

大概就是这些了。

代码6K...

#include <cstdio>
#include <cstring>
#include <algorithm>
const int N = 30;

int n, ans;
int bin[300000];

inline void out() {
    for(int i = 3; i <= 15; i++) {
        printf("%3d", bin[i]);
    }
    printf("%3d
", bin[1]);
    return;
}

inline void read() {
    int x;
    scanf("%d", &x);
    if(x) {
        if(x < 3) {
            x += 13;
        }
        bin[x]++;
    }
    else {
        bin[1]++;
    }
    scanf("%d", &x);
    return;
}
void DFS(int, int, int);

void one_link(int rest, int time, int t, int pos) {
    int l = std::max(pos, 3);
    while(!bin[l] && l <= 15) {
        l++;
    }
    if(l >= 11) {
        DFS(rest, time, t + 1);
        return;
    }
    int r = l + 1;
    while(r < 15 && bin[r]) {
        r++;
    }

    if(r - l >= 5) {
        for(int j = l + 5; j <= r; j++) {
            for(int i = l; i < j; i++) {
                bin[i]--;
            }
            one_link(rest - (j - l), time + 1, t, l);
            for(int i = l; i < j; i++) {
                bin[i]++;
            }
        }
    }
    one_link(rest, time, t, l + 1);
    return;
}

void two_link(int rest, int time, int t, int pos) {
    int l = std::max(pos, 3);
    while(bin[l] < 2 && l <= 15) {
        l++;
    }
    if(l >= 13) {
        DFS(rest, time, t + 1);
        return;
    }
    int r = l + 1;
    while(r < 15 && bin[r] > 1) {
        r++;
    }

    if(r - l >= 3) {
        for(int j = l + 3; j <= r; j++) {
            /// [l, j)
            for(int i = l; i < j; i++) {
                bin[i] -= 2;
            }
            two_link(rest - 2 * (j - l), time + 1, t, l);
            for(int i = l; i < j; i++) {
                bin[i] += 2;
            }
        }
    }
    two_link(rest, time, t, l + 1);
    return;
}

void three_link(int rest, int time, int t, int pos) {
    int l = std::max(pos, 3);;
    while(bin[l] < 3 && l <= 15) {
        l++;
    }
    if(l >= 14) {
        DFS(rest, time, t + 1);
        return;
    }
    int r = l + 1;
    while(r < 15 && bin[r] > 2) {
        r++;
    }

    if(r - l >= 2) {
        for(int j = l + 2; j <= r; j++) {
            /// [l, j)
            for(int i = l; i < j; i++) {
                bin[i] -= 3;
            }
            three_link(rest - 3 * (j - l), time + 1, t, l);
            for(int i = l; i < j; i++) {
                bin[i] += 3;
            }
        }
        if(r - l > 2) {
            three_link(rest, time, t, l + 1);
        }
        else {
            three_link(rest, time, t, r + 1);
        }
    }
    else {
        three_link(rest, time, t, r + 1);
    }
    return;
}

void four_four(int rest, int time, int t, int pos) {
    int p = std::max(pos, 3);
    while(bin[p] < 4 && p <= 15) {
        p++;
    }
    if(p == 16) {
        DFS(rest, time, t + 1);
        return;
    }
    bin[p] -= 4;
    for(int i = 3; i <= 15; i++) {
        if(bin[i] > 1) {
            bin[i] -= 2;
            for(int j = i; j <= 15; j++) {
                if(bin[j] > 1) {
                    bin[j] -= 2;
                    four_four(rest - 8, time + 1, t, p);
                    bin[j] += 2;
                }
            }
            bin[i] += 2;
        }
    }
    bin[p] += 4;
    four_four(rest, time, t, p + 1);
    return;
}

void four_two(int rest, int time, int t, int pos) {
    int p = std::max(pos, 3);
    while(bin[p] < 4 && p <= 15) {
        p++;
    }
    if(p == 16) {
        DFS(rest, time, t + 1);
        return;
    }
    bin[p] -= 4;
    for(int i = 1; i <= 15; i++) {
        if(bin[i]) {
            bin[i]--;
            for(int j = i; j <= 15; j++) {
                if(bin[j]) {
                    bin[j]--;
                    four_two(rest - 6, time + 1, t, p);
                    bin[j]++;
                }
            }
            bin[i]++;
        }
    }
    bin[p] += 4;
    four_two(rest, time, t, p + 1);
    return;
}

void three_two(int rest, int time, int t, int pos) {
    int p = std::max(3, pos);
    while(bin[p] < 3 && p <= 15) {
        p++;
    }
    if(p == 16) {
        DFS(rest, time, t + 1);
        return;
    }
    bin[p] -= 3;
    for(int i = 3; i <= 15; i++) {
        if(bin[i] > 1) {
            bin[i] -= 2;
            three_two(rest - 5, time + 1, t, p);
            bin[i] += 2;
        }
    }
    bin[p] += 3;
    three_two(rest, time, t, p + 1);
    return;
}

void three_one(int rest, int time, int t, int pos) {
    int p = std::max(pos, 3);
    while(bin[p] < 3 && p <= 15) {
        p++;
    }
    if(p == 16) {
        DFS(rest, time, t + 1);
        return;
    }
    bin[p] -= 3;
    for(int i = 1; i <= 15; i++) {
        if(bin[i] && i != p) {
            bin[i]--;
            three_one(rest - 4, time + 1, t, p);
            bin[i]++;
        }
    }
    bin[p] += 3;
    three_one(rest, time, t, p + 1);
    return;
}

void DFS(int rest, int time, int t) {
    if(!rest) {
        ans = std::min(ans, time);
        return;
    }
    if(time >= ans - 1) {
        return;
    }
    if(!t) {
        one_link(rest, time, t, 0);
    }
    else if(t == 1) {
        two_link(rest, time, t, 0);
    }
    else if(t == 2) {
        three_link(rest, time, t, 0);
    }
    else if(t == 3) {
        four_four(rest, time, t, 0);
    }
    else if(t == 4) {
        four_two(rest, time, t, 0);
    }
    else if(t == 5) {
        three_two(rest, time, t, 0);
    }
    else if(t == 6) {
        three_one(rest, time, t, 0);
    }
    else {
        int a = 0;
        for(int i = 1; i <= 15; i++) {
            a += (bin[i] > 0);
        }
        ans = std::min(ans, time + a);
    }
    return;
}

inline void solve() {
    ans = 0;
    for(int i = 1; i <= 15; i++) {
        ans += (bin[i] > 0);
    }
    DFS(n, 0, 0);
    printf("%d
", ans);
    return;
}

int main() {
    int T;
    scanf("%d%d", &T, &n);
    while(T--) {
        for(int i = 1; i <= n; i++) {
            read();
        }
        solve();
        if(T) {
            memset(bin, 0, sizeof(bin));
        }
    }

    return 0;
}

顺手把增强版也A了，跑的贼快。

数组300000是之前调的，忘了改回来。