Ideone.com

fork download

copy

#include<bits/stdc++.h>
#define FOR(i, a, b) for (int i = (a), _b = (b); i <= _b; i++)
#define FORD(i, b, a) for (int i = (b), _a = (a); i >= _a; i--)
#define REP(i, n) for (int i = 0, _n = (n); i < _n; i++)
#define FORE(i, v) for (__typeof((v).begin()) i = (v).begin(); i != (v).end(); i++)
#define ALL(v) (v).begin(), (v).end()
#define IS_INF(x)   (std::isinf(x))
#define IS_NAN(x)   (std::isnan(x))
#define fi   first
#define se   second
#define MASK(i) (1LL << (i))
#define BIT(x, i) (((x) >> (i)) & 1)
#define div   ___div
#define next   ___next
#define prev   ___prev
#define left   ___left
#define right   ___right
#define __builtin_popcount __builtin_popcountll
using namespace std;
template<class X, class Y>
    bool minimize(X &x, const Y &y) {
        X eps = 1e-9;
        if (x > y + eps) {
            x = y;
            return true;
        } else return false;
    }
template<class X, class Y>
    bool maximize(X &x, const Y &y) {
        X eps = 1e-9;
        if (x + eps < y) {
            x = y;
            return true;
        } else return false;
    }
template<class T>
    T Abs(const T &x) {
        return (x < 0 ? -x : x);
    }
 
/* Author: Van Hanh Pham */
 
class DisjointSet {
private:
    vector<int> lab;
 
public:
    DisjointSet(int n = 0) {
        lab.assign(n + 7, -1);
    }
 
    int find(int x) {
        return lab[x] < 0 ? x : lab[x] = find(lab[x]);
    }
 
    bool join(int u, int v) {
        int x = find(u), y = find(v);
        if (x == y) return false;
 
        if (lab[x] > lab[y]) swap(x, y);
        lab[x] += lab[y];
        lab[y] = x;
        return true;
    }
 
    int getSize(int u) {
        return -lab[find(u)];
    }
};
 
/** END OF TEMPLATE. DRINK A CUP OF TIGERSUGAR BEFORE READING MY CODE. **/
 
struct Clue {
    int u, v, sign;
 
    Clue(int _u = 0, int _v = 0, char _sign = 0) {
        u = _u; v = _v;
        sign = _sign == '=' ? 0 : (_sign == '<' ? -1 : 1);
    }
};
 
#define MAX_SIZE   300300
#define MAX_CLUE   500500
#define LOG   20
 
int numValue, numClue, numZero, numOne;
Clue clues[MAX_CLUE];
 
void init(void) {
    scanf("%d%d%d", &numValue, &numClue, &numZero);
    numOne = numValue - numZero;
 
    FOR(i, 1, numClue) {
        char s[5];
        int u, v;
        scanf("%d%s%d", &u, s, &v);
        clues[i] = Clue(u, v, s[0]);
    }
}
 
int numCompBySize[MAX_SIZE];
int buildComponent(int t) {
    DisjointSet dsu(numValue + 2);
    int zeroComp = numValue + 1;
    int oneComp = numValue + 2;
 
    FOR(i, 1, t) {
        int u = clues[i].u, v = clues[i].v;
        if (clues[i].sign == 0) dsu.join(u, v);
        else {
            if (clues[i].sign > 0) swap(u, v);
            dsu.join(zeroComp, u);
            dsu.join(oneComp, v);
        }
    }
 
    int zeroRoot = dsu.find(zeroComp);
    int oneRoot = dsu.find(oneComp);
 
    memset(numCompBySize, 0, (numValue + 1) * sizeof (int));
    FOR(i, 1, numValue) if (i != zeroRoot && i != oneRoot && dsu.find(i) == i)
        numCompBySize[dsu.getSize(i)]++;
 
    return numZero - dsu.getSize(zeroComp) + 1;
    return min(numZero - dsu.getSize(zeroComp), numOne - dsu.getSize(oneComp)) + 1;
}
 
#define Bitset bitset<BIT_SET_SIZE>
template<int BIT_SET_SIZE>
    string printBitset(const Bitset &bs, int needZero) {
        stringstream stream;
        stream << "(";
        REP(i, needZero + 1) if (bs[i]) stream << i << ", ";
        stream << ")";
        return stream.str();
    }
 
template<int BIT_SET_SIZE>
    bool checkUnique(int needZero) {
        if (needZero == 0) return true;
        assert(needZero < BIT_SET_SIZE);
 
//        printf("CHECKING UNIQUE %d zeros\n", needZero);
        vector<int> sizes;
        FOR(i, 1, needZero) if (numCompBySize[i] > 0) sizes.push_back(i);
 
        Bitset oneWay, manyWay;
        oneWay[0] = true;
    //    cerr << "oneway: " << printBitset(oneWay, needZero) << endl;
    //    cerr << "manyway: " << printBitset(manyWay, needZero) << endl;
 
        FORE(it, sizes) {
            int compSize = *it;
            int numComp = numCompBySize[compSize];
//            printf("There are %d comps of size %d\n", numComp, compSize);
 
            if (numComp > 1) {
                Bitset combined = (oneWay | manyWay) << compSize;
                manyWay |= manyWay << (numComp * compSize);
                int mask = 1;
                while ((mask << 1) < numComp) {
                    combined = combined | (combined << (mask * compSize));
                    mask <<= 1;
                    if (combined[needZero]) return false;
                }
                manyWay |= combined | (combined << (numComp - 1 - mask) * compSize);
            } else manyWay |= manyWay << (numComp * compSize);
 
            Bitset tmp = oneWay << (compSize * numComp);
            manyWay |= oneWay & tmp;
            oneWay |= tmp;
            oneWay &= ~manyWay;
 
    //        cerr << "oneway: " << printBitset(oneWay, needZero) << endl;
    //        cerr << "manyway: " << printBitset(manyWay, needZero) << endl;
            if (manyWay[needZero]) return false;
        }
 
        assert(oneWay[needZero] || manyWay[needZero]);
        return !manyWay[needZero];
    }
 
bool checkUniqueWithDynamicSize(int needZero) {
    if (needZero < 10) return checkUnique<10>(needZero);
    if (needZero < 20) return checkUnique<20>(needZero);
    if (needZero < 30) return checkUnique<30>(needZero);
    if (needZero < 40) return checkUnique<40>(needZero);
    if (needZero < 50) return checkUnique<50>(needZero);
    if (needZero < 60) return checkUnique<60>(needZero);
    if (needZero < 70) return checkUnique<70>(needZero);
    if (needZero < 80) return checkUnique<80>(needZero);
    if (needZero < 90) return checkUnique<90>(needZero);
    if (needZero < 100) return checkUnique<100>(needZero);
    if (needZero < 200) return checkUnique<200>(needZero);
    if (needZero < 300) return checkUnique<300>(needZero);
    if (needZero < 400) return checkUnique<400>(needZero);
    if (needZero < 500) return checkUnique<500>(needZero);
    if (needZero < 600) return checkUnique<600>(needZero);
    if (needZero < 700) return checkUnique<700>(needZero);
    if (needZero < 800) return checkUnique<800>(needZero);
    if (needZero < 900) return checkUnique<900>(needZero);
    if (needZero < 1000) return checkUnique<1000>(needZero);
    if (needZero < 2000) return checkUnique<2000>(needZero);
    if (needZero < 3000) return checkUnique<3000>(needZero);
    if (needZero < 4000) return checkUnique<4000>(needZero);
    if (needZero < 5000) return checkUnique<5000>(needZero);
    if (needZero < 6000) return checkUnique<6000>(needZero);
    if (needZero < 7000) return checkUnique<7000>(needZero);
    if (needZero < 8000) return checkUnique<8000>(needZero);
    if (needZero < 9000) return checkUnique<9000>(needZero);
    if (needZero < 10000) return checkUnique<10000>(needZero);
    if (needZero < 20000) return checkUnique<20000>(needZero);
    if (needZero < 30000) return checkUnique<30000>(needZero);
    if (needZero < 40000) return checkUnique<40000>(needZero);
    if (needZero < 50000) return checkUnique<50000>(needZero);
    if (needZero < 60000) return checkUnique<60000>(needZero);
    if (needZero < 70000) return checkUnique<70000>(needZero);
    if (needZero < 80000) return checkUnique<80000>(needZero);
    if (needZero < 90000) return checkUnique<90000>(needZero);
    if (needZero < 100000) return checkUnique<100000>(needZero);
    if (needZero < 200000) return checkUnique<200000>(needZero);
    if (needZero < 300000) return checkUnique<300000>(needZero);
    if (needZero < 400000) return checkUnique<400000>(needZero);
    if (needZero < 500000) return checkUnique<500000>(needZero);
    if (needZero < 600000) return checkUnique<600000>(needZero);
    if (needZero < 700000) return checkUnique<700000>(needZero);
    if (needZero < 800000) return checkUnique<800000>(needZero);
    if (needZero < 900000) return checkUnique<900000>(needZero);
    assert(false);
}
 
bool ok(int t) {
//    printf("CHECKING %d\n", t);
    int needZero = buildComponent(t);
    return checkUniqueWithDynamicSize(needZero);
}
 
int process(void) {
    if (numZero == 0 || numZero == numValue) return 0;
    if (numClue == 0 || !ok(numClue)) return -1;
 
    int L = 1, R = numClue;
 
    while (true) {
        if (L == R) return L;
        if (R - L == 1) return ok(L) ? L : R;
        int M = (L + R) >> 1;
        if (ok(M)) R = M; else L = M + 1;
    }
 
}
 
int main(void) {
//    freopen("tests/huge_3.in", "r", stdin);
    int numTest; scanf("%d", &numTest);
    REP(love, numTest) {
        init();
        int result = process();
        printf("%d\n", result);
//        fprintf(stderr, "%d out of %d (%.2lf%%) (#zero = %d, #clue = %d)\n",
//                        result, numValue, 100.0 * result / numValue, numZero, numClue);
    }
    return 0;
}
 
/*** BUBBLE TEA IS GREAT. MY CODE IS AMAZING :D ***/

#include<bits/stdc++.h>
#define FOR(i, a, b) for (int i = (a), _b = (b); i <= _b; i++)
#define FORD(i, b, a) for (int i = (b), _a = (a); i >= _a; i--)
#define REP(i, n) for (int i = 0, _n = (n); i < _n; i++)
#define FORE(i, v) for (__typeof((v).begin()) i = (v).begin(); i != (v).end(); i++)
#define ALL(v) (v).begin(), (v).end()
#define IS_INF(x)   (std::isinf(x))
#define IS_NAN(x)   (std::isnan(x))
#define fi   first
#define se   second
#define MASK(i) (1LL << (i))
#define BIT(x, i) (((x) >> (i)) & 1)
#define div   ___div
#define next   ___next
#define prev   ___prev
#define left   ___left
#define right   ___right
#define __builtin_popcount __builtin_popcountll
using namespace std;
template<class X, class Y>
    bool minimize(X &x, const Y &y) {
        X eps = 1e-9;
        if (x > y + eps) {
            x = y;
            return true;
        } else return false;
    }
template<class X, class Y>
    bool maximize(X &x, const Y &y) {
        X eps = 1e-9;
        if (x + eps < y) {
            x = y;
            return true;
        } else return false;
    }
template<class T>
    T Abs(const T &x) {
        return (x < 0 ? -x : x);
    }

/* Author: Van Hanh Pham */

class DisjointSet {
private:
    vector<int> lab;

public:
    DisjointSet(int n = 0) {
        lab.assign(n + 7, -1);
    }

    int find(int x) {
        return lab[x] < 0 ? x : lab[x] = find(lab[x]);
    }

    bool join(int u, int v) {
        int x = find(u), y = find(v);
        if (x == y) return false;

        if (lab[x] > lab[y]) swap(x, y);
        lab[x] += lab[y];
        lab[y] = x;
        return true;
    }

    int getSize(int u) {
        return -lab[find(u)];
    }
};

/** END OF TEMPLATE. DRINK A CUP OF TIGERSUGAR BEFORE READING MY CODE. **/

struct Clue {
    int u, v, sign;

    Clue(int _u = 0, int _v = 0, char _sign = 0) {
        u = _u; v = _v;
        sign = _sign == '=' ? 0 : (_sign == '<' ? -1 : 1);
    }
};

#define MAX_SIZE   300300
#define MAX_CLUE   500500
#define LOG   20

int numValue, numClue, numZero, numOne;
Clue clues[MAX_CLUE];

void init(void) {
    scanf("%d%d%d", &numValue, &numClue, &numZero);
    numOne = numValue - numZero;

    FOR(i, 1, numClue) {
        char s[5];
        int u, v;
        scanf("%d%s%d", &u, s, &v);
        clues[i] = Clue(u, v, s[0]);
    }
}

int numCompBySize[MAX_SIZE];
int buildComponent(int t) {
    DisjointSet dsu(numValue + 2);
    int zeroComp = numValue + 1;
    int oneComp = numValue + 2;

    FOR(i, 1, t) {
        int u = clues[i].u, v = clues[i].v;
        if (clues[i].sign == 0) dsu.join(u, v);
        else {
            if (clues[i].sign > 0) swap(u, v);
            dsu.join(zeroComp, u);
            dsu.join(oneComp, v);
        }
    }

    int zeroRoot = dsu.find(zeroComp);
    int oneRoot = dsu.find(oneComp);

    memset(numCompBySize, 0, (numValue + 1) * sizeof (int));
    FOR(i, 1, numValue) if (i != zeroRoot && i != oneRoot && dsu.find(i) == i)
        numCompBySize[dsu.getSize(i)]++;

    return numZero - dsu.getSize(zeroComp) + 1;
    return min(numZero - dsu.getSize(zeroComp), numOne - dsu.getSize(oneComp)) + 1;
}

#define Bitset bitset<BIT_SET_SIZE>
template<int BIT_SET_SIZE>
    string printBitset(const Bitset &bs, int needZero) {
        stringstream stream;
        stream << "(";
        REP(i, needZero + 1) if (bs[i]) stream << i << ", ";
        stream << ")";
        return stream.str();
    }

template<int BIT_SET_SIZE>
    bool checkUnique(int needZero) {
        if (needZero == 0) return true;
        assert(needZero < BIT_SET_SIZE);

//        printf("CHECKING UNIQUE %d zeros\n", needZero);
        vector<int> sizes;
        FOR(i, 1, needZero) if (numCompBySize[i] > 0) sizes.push_back(i);

        Bitset oneWay, manyWay;
        oneWay[0] = true;
    //    cerr << "oneway: " << printBitset(oneWay, needZero) << endl;
    //    cerr << "manyway: " << printBitset(manyWay, needZero) << endl;

        FORE(it, sizes) {
            int compSize = *it;
            int numComp = numCompBySize[compSize];
//            printf("There are %d comps of size %d\n", numComp, compSize);

            if (numComp > 1) {
                Bitset combined = (oneWay | manyWay) << compSize;
                manyWay |= manyWay << (numComp * compSize);
                int mask = 1;
                while ((mask << 1) < numComp) {
                    combined = combined | (combined << (mask * compSize));
                    mask <<= 1;
                    if (combined[needZero]) return false;
                }
                manyWay |= combined | (combined << (numComp - 1 - mask) * compSize);
            } else manyWay |= manyWay << (numComp * compSize);

            Bitset tmp = oneWay << (compSize * numComp);
            manyWay |= oneWay & tmp;
            oneWay |= tmp;
            oneWay &= ~manyWay;

    //        cerr << "oneway: " << printBitset(oneWay, needZero) << endl;
    //        cerr << "manyway: " << printBitset(manyWay, needZero) << endl;
            if (manyWay[needZero]) return false;
        }

        assert(oneWay[needZero] || manyWay[needZero]);
        return !manyWay[needZero];
    }

bool checkUniqueWithDynamicSize(int needZero) {
    if (needZero < 10) return checkUnique<10>(needZero);
    if (needZero < 20) return checkUnique<20>(needZero);
    if (needZero < 30) return checkUnique<30>(needZero);
    if (needZero < 40) return checkUnique<40>(needZero);
    if (needZero < 50) return checkUnique<50>(needZero);
    if (needZero < 60) return checkUnique<60>(needZero);
    if (needZero < 70) return checkUnique<70>(needZero);
    if (needZero < 80) return checkUnique<80>(needZero);
    if (needZero < 90) return checkUnique<90>(needZero);
    if (needZero < 100) return checkUnique<100>(needZero);
    if (needZero < 200) return checkUnique<200>(needZero);
    if (needZero < 300) return checkUnique<300>(needZero);
    if (needZero < 400) return checkUnique<400>(needZero);
    if (needZero < 500) return checkUnique<500>(needZero);
    if (needZero < 600) return checkUnique<600>(needZero);
    if (needZero < 700) return checkUnique<700>(needZero);
    if (needZero < 800) return checkUnique<800>(needZero);
    if (needZero < 900) return checkUnique<900>(needZero);
    if (needZero < 1000) return checkUnique<1000>(needZero);
    if (needZero < 2000) return checkUnique<2000>(needZero);
    if (needZero < 3000) return checkUnique<3000>(needZero);
    if (needZero < 4000) return checkUnique<4000>(needZero);
    if (needZero < 5000) return checkUnique<5000>(needZero);
    if (needZero < 6000) return checkUnique<6000>(needZero);
    if (needZero < 7000) return checkUnique<7000>(needZero);
    if (needZero < 8000) return checkUnique<8000>(needZero);
    if (needZero < 9000) return checkUnique<9000>(needZero);
    if (needZero < 10000) return checkUnique<10000>(needZero);
    if (needZero < 20000) return checkUnique<20000>(needZero);
    if (needZero < 30000) return checkUnique<30000>(needZero);
    if (needZero < 40000) return checkUnique<40000>(needZero);
    if (needZero < 50000) return checkUnique<50000>(needZero);
    if (needZero < 60000) return checkUnique<60000>(needZero);
    if (needZero < 70000) return checkUnique<70000>(needZero);
    if (needZero < 80000) return checkUnique<80000>(needZero);
    if (needZero < 90000) return checkUnique<90000>(needZero);
    if (needZero < 100000) return checkUnique<100000>(needZero);
    if (needZero < 200000) return checkUnique<200000>(needZero);
    if (needZero < 300000) return checkUnique<300000>(needZero);
    if (needZero < 400000) return checkUnique<400000>(needZero);
    if (needZero < 500000) return checkUnique<500000>(needZero);
    if (needZero < 600000) return checkUnique<600000>(needZero);
    if (needZero < 700000) return checkUnique<700000>(needZero);
    if (needZero < 800000) return checkUnique<800000>(needZero);
    if (needZero < 900000) return checkUnique<900000>(needZero);
    assert(false);
}

bool ok(int t) {
//    printf("CHECKING %d\n", t);
    int needZero = buildComponent(t);
    return checkUniqueWithDynamicSize(needZero);
}

int process(void) {
    if (numZero == 0 || numZero == numValue) return 0;
    if (numClue == 0 || !ok(numClue)) return -1;

    int L = 1, R = numClue;

    while (true) {
        if (L == R) return L;
        if (R - L == 1) return ok(L) ? L : R;
        int M = (L + R) >> 1;
        if (ok(M)) R = M; else L = M + 1;
    }

}

int main(void) {
//    freopen("tests/huge_3.in", "r", stdin);
    int numTest; scanf("%d", &numTest);
    REP(love, numTest) {
        init();
        int result = process();
        printf("%d\n", result);
//        fprintf(stderr, "%d out of %d (%.2lf%%) (#zero = %d, #clue = %d)\n",
//                        result, numValue, 100.0 * result / numValue, numZero, numClue);
    }
    return 0;
}

/*** BUBBLE TEA IS GREAT. MY CODE IS AMAZING :D ***/

Success #stdin #stdout 0.02s 9648KB

stdin

copy

Standard input is empty

stdout

copy

https://ideone.com/j8gq1l

language:

C++ 4.3.2 (gcc-4.3.2)

created:

visibility:

public

Share or Embed source code

Discover > Sphere Engine API

The brand new service which powers Ideone!

Discover > IDE Widget

Widget for compiling and running the source code in a web browser!

Discover > Sphere Engine API

Discover > IDE Widget

Choose your language