Submission #364041

#	Time	Username	Problem	Language	Result	Execution time	Memory
364041		Andyvanh1	Love Polygon (BOI18_polygon)	C++11	Compilation error	0 ms	0 KiB

polygon

using namespace std;


// 17.4.1.2 Headers

// C


#ifndef _GLIBCXX_NO_ASSERT
#include <cassert>
#endif
#include <cctype>
#include <cerrno>
#include <cfloat>
#include <ciso646>
#include <climits>
#include <clocale>
#include <cmath>
#include <csetjmp>
#include <csignal>
#include <cstdarg>
#include <cstddef>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>

#if __cplusplus >= 201103L
#include <ccomplex>
#include <cfenv>
#include <cinttypes>
#include <cstdbool>
#include <cstdint>
#include <ctgmath>
#include <cwchar>
#include <cwctype>
#endif

// C++
#include <algorithm>
#include <bitset>
#include <complex>
#include <deque>
#include <exception>
#include <fstream>
#include <functional>
#include <iomanip>
#include <ios>
#include <iosfwd>
#include <iostream>
#include <istream>
#include <iterator>
#include <limits>
#include <list>
#include <locale>
#include <map>
#include <memory>
#include <new>
#include <numeric>
#include <ostream>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <stdexcept>
#include <streambuf>
#include <string>
#include <typeinfo>
#include <utility>
#include <valarray>
#include <vector>

#if __cplusplus >= 201103L
#include <array>
#include <atomic>
#include <chrono>
#include <condition_variable>
#include <forward_list>
#include <future>
#include <initializer_list>
#include <mutex>
#include <random>
#include <ratio>
#include <regex>
#include <scoped_allocator>
#include <system_error>
#include <thread>
#include <tuple>
#include <typeindex>
#include <type_traits>
#include <unordered_map>
#include <unordered_set>
#endif

#define ll long long
#define ld long double
#define ar array

typedef priority_queue<int> pqi;
typedef pair<int,int> pii;
typedef vector<pair<int,int>> vpii;
typedef vector<int> vi;

ll gcd(ll a, ll b) {
    if (!a || !b)
        return a | b;
    unsigned shift = __builtin_ctz(a | b);
    a >>= __builtin_ctz(a);
    do {
        b >>= __builtin_ctz(b);
        if (a > b)
            swap(a, b);
        b -= a;
    } while (b);
    return a << shift;
}

ll lcm(ll a, ll b){
    return (ll)a*b/gcd(a,b);
}


#define vt vector
#define pb push_back
#define all(c) (c).begin(), (c).end()
#define sz(x) (int)(x).size()

#define F_OR(i, a, b, s) for (int i=(a); (s)>0?i<(b):i>(b); i+=(s))
#define FORR1(e) F_OR(i, 0, e, 1)
#define FORR2(i, e) F_OR(i, 0, e, 1)
#define FORR3(i, b, e) F_OR(i, b, e, 1)
#define FORR4(i, b, e, s) F_OR(i, b, e, s)
#define GET5(a, b, c, d, e, ...) e
#define F_ORC(...) GET5(__VA_ARGS__, FORR4, FORR3, FORR2, FORR1)
#define FOR(...) F_ORC(__VA_ARGS__)(__VA_ARGS__)
#define EACH(x, a) for (auto& x: a)
const int INF = 2*((1<<30)-1)+1;

int lsb(int i){
    return i&-i;
}


template<class T> bool umin(T& a, const T& b) {
    return b<a?a=b, 1:0;
}
template<class T> bool umax(T& a, const T& b) {
    return a<b?a=b, 1:0;
}

int binarySearch(vi arr, int p, int r, int num) {
    if (p <= r) {
        int mid = (p + r)/2;
        if (arr[mid] == num)
            return mid ;
        if (arr[mid] > num)
            return binarySearch(arr, p, mid-1, num);
        if (arr[mid] > num)
            return binarySearch(arr, mid+1, r, num);
    }
    return -1;
}






ll FIRSTTRUE(function<bool(ll)> f, ll lb, ll rb) {
    while(lb<rb) {
        ll mb=(lb+rb)/2;
        f(mb)?rb=mb:lb=mb+1;
    }
    return lb;
}
ll LASTTRUE(function<bool(ll)> f, ll lb, ll rb) {
    while(lb<rb) {
        ll mb=(lb+rb+1)/2;
        f(mb)?lb=mb:rb=mb-1;
    }
    return lb;
}

template<class A> void read(vt<A>& v);
template<class A, size_t S> void read(ar<A, S>& a);
template<class T> void read(T& x) {
    cin >> x;
}
void read(double& d) {
    string t;
    read(t);
    d=stod(t);
}
void read(long double& d) {
    string t;
    read(t);
    d=stold(t);
}
template<class H, class... T> void read(H& h, T&... t) {
    read(h);
    read(t...);
}
template<class A> void read(vt<A>& x) {
    EACH(a, x)
        read(a);
}
template<class A, size_t S> void read(array<A, S>& x) {
    EACH(a, x)
        read(a);
}

string to_string(char c) {
    return string(1, c);
}
string to_string(bool b) {
    return b?"true":"false";
}
string to_string(const char* s) {
    return string(s);
}
string to_string(string s) {
    return s;
}
string to_string(vt<bool> v) {
    string res;
    FOR(sz(v))
        res+=char('0'+v[i]);
    return res;
}

template<size_t S> string to_string(bitset<S> b) {
    string res;
    FOR(S)
        res+=char('0'+b[i]);
    return res;
}
template<class T> string to_string(T v) {
    bool f=1;
    string res;
    EACH(x, v) {
        if(!f)
            res+=' ';
        f=0;
        res+=to_string(x);
    }
    return res;
}

template<class A> void write(A x) {
    cout << to_string(x);
}
template<class H, class... T> void write(const H& h, const T&... t) {
    write(h);
    write(t...);
}
void print() {
    write("\n");
}
template<class H, class... T> void print(const H& h, const T&... t) {
    write(h);
    if(sizeof...(t))
        write(' ');
    print(t...);
}

void DBG() {
    cerr << "]" << endl;
}
template<class H, class... T> void DBG(H h, T... t) {
    cerr << to_string(h);
    if(sizeof...(t))
        cerr << ", ";
    DBG(t...);
}
#ifdef _DEBUG
#define dbg(...) cerr << "LINE(" << __LINE__ << ") -> [" << #__VA_ARGS__ << "]: [", DBG(__VA_ARGS__)
#else
#define dbg(...) 0
#endif

template<class T> void offset(ll o, T& x) {
    x+=o;
}
template<class T> void offset(ll o, vt<T>& x) {
    EACH(a, x)
        offset(o, a);
}
template<class T, size_t S> void offset(ll o, ar<T, S>& x) {
    EACH(a, x)
        offset(o, a);
}

mt19937 mt_rng(chrono::steady_clock::now().time_since_epoch().count());
ll randint(ll a, ll b) {
    return uniform_int_distribution<ll>(a, b)(mt_rng);
}

template<class T, class U> void vti(vt<T> &v, U x, size_t n) {
    v=vt<T>(n, x);
}
template<class T, class U> void vti(vt<T> &v, U x, size_t n, size_t m...) {
    v=vt<T>(n);
    EACH(a, v)
        vti(a, x, m);
}

const int d4i[4]={-1, 0, 1, 0}, d4j[4]={0, 1, 0, -1};
const int d8i[8]={-1, -1, 0, 1, 1, 1, 0, -1}, d8j[8]={0, 1, 1, 1, 0, -1, -1, -1};
const int mxN=5e5+1, M=1e9+7;
int n, m, p[mxN];

int find(int x) {
    return x^p[x]?p[x]=find(p[x]):x;
}

bool join(int x, int y) {
    if((x=find(x))==(y=find(y)))
        return 0;
    p[x]=y;
    return 1;
}


vi ans;
vt<vi> adjlist;
queue<int> nodelist;
vt<bool> visited;
vt<vi> weightlist;
void bfs(int start){

    ans[start] = 0;
    nodelist.push(start);
    while(!nodelist.empty()){
        int node = nodelist.front();
        visited[node] = true;
        for(int e : adjlist[node]){
            if(!visited[e]){
                nodelist.push(e);
                ans[e] = ans[node]+1;
                visited[e] = true;
            }
        }

        nodelist.pop();
    }




}

int pmst(int start){
    int n = adjlist.size();
    visited.resize(n);
    FORR1(n){
        visited[i] = false;
    }
    visited[start] = true;
    priority_queue<pair<int,pair<int,int>>,vt<pair<int,pair<int,int>>>,greater<pair<int,pair<int,int>>>> pq;

    for(int i = 0; i < adjlist[start].size(); i++){
        pq.push(make_pair(weightlist[start][i],make_pair(start,adjlist[start][i])));
    }

    stack<int> nodes;
    int ans = 0;
    nodes.push(start);

    while(nodes.size()!=n){
        pair<int,pair<int,int>> trip = pq.top();
        pq.pop();
        int w = trip.first;
        int a = trip.second.first;
        int b = trip.second.second;

        if(visited[a]&&visited[b]){
            continue;
        }

        visited[b] = true;
        nodes.push(b);
        ans+=w;

        FORR1(adjlist[b].size()){
            if(!visited[adjlist[b][i]]){
                pq.push(make_pair(weightlist[b][i],make_pair(b,adjlist[b][i])));
            }
        }
    }

return ans;
}

void dfs(int node){

}

void update(vi arr, int index, int val){
    int n = arr.size();
    int x = index+(1<<lsb(index+1));
    int og = arr[index];
    arr[index] = val;

    while(x<n){
        arr[x]/=og;
        arr[x]*=val;
        x = x + (1<<lsb(x+1));
    }
}

int query(vi arr, int val){
    int ans = 0;
    val++;
    while(val!=0){
        ans*=arr[val-1];
        val-(1<<lsb(val));
    }
    return ans;
}

string reverse(string s){

    string str = "";

    for(int i = s.length()-1; i >=0; i--){
        str+=s.substr(i,1);
    }
return str;

}

string leximax(string a, string b){
    if(a>b){
        return a;
    }
    return b;
}

string leximin(string a, string b){
    if(a>b){
        return b;
    }
    return a;
}

bool gemacht(int num, vi p){

}

bool issorted(vi arr){
    int b = true;
    int n = arr.size();
    for(int i = 1; i < n; i++){
        if(arr[i]<arr[i-1]){
            b = false;
            break;
        }
    }
    return b;
}

bool continuous(vi arr){
    int n = arr.size();
    bool bol = true;
    for(int i = 1; i < n; i++){
        if(arr[i]-arr[i-1]!=1){
            bol = false;
            break;
        }
    }
    return bol;
}

vi arr;
vi Max;
vi Min;
vi Sizze;
int Maxs;
int Comps;

int get(int node){
    return arr[node] = (arr[node] == node ? node : get(arr[node]));

}
void unn(int node1, int node2){
    if(get(node1)!=get(node2)){

        Sizze[get(node1)]+=Sizze[get(node2)];
        Maxs = max(Maxs,Sizze[get(node1)]);
        Comps--;
        arr[get(node2)] = get(node1);

    }

}

int beginn;
int endd;
void query(){
    write("? ",(beginn+endd)/2);
    fflush(stdout);
    read(ans);


}



void solve() {
    int n;
    read(n);
    map<string,string> Map;
    vt<string> arr(n);
    FORR1(n){
        string s1, s2;
        read(s1,s2);
        Map.insert({s1,s2});
        arr[i] = s1;
    }
    if(n%2==1){
        write(-1);
        return;
    }
    int ans = n/2;
    int x = 0;
    FORR1(n){
        if(arr[i]==Map[Map[arr[i]]]&&arr[i]!=Map[arr[i]]){
            x++;
        }
    }
    ans-=x/2;

    int y = 0;

    FORR1(n){
        if(arr[i]==Map[arr[i]]){
            y++;
        }
    }
    ans+=(int)ceil((double)y/2);

    write(ans);
}

Compilation message (stderr)

polygon.cpp: In function 'int pmst(int)':
polygon.cpp:361:22: warning: comparison of integer expressions of different signedness: 'int' and 'std::vector<int>::size_type' {aka 'long unsigned int'} [-Wsign-compare]
  361 |     for(int i = 0; i < adjlist[start].size(); i++){
      |                    ~~^~~~~~~~~~~~~~~~~~~~~~~
polygon.cpp:369:23: warning: comparison of integer expressions of different signedness: 'std::stack<int>::size_type' {aka 'long unsigned int'} and 'int' [-Wsign-compare]
  369 |     while(nodes.size()!=n){
      |           ~~~~~~~~~~~~^~~
polygon.cpp:128:49: warning: comparison of integer expressions of different signedness: 'int' and 'std::vector<int>::size_type' {aka 'long unsigned int'} [-Wsign-compare]
  128 | #define F_OR(i, a, b, s) for (int i=(a); (s)>0?i<(b):i>(b); i+=(s))
      |                                                 ^
polygon.cpp:129:18: note: in expansion of macro 'F_OR'
  129 | #define FORR1(e) F_OR(i, 0, e, 1)
      |                  ^~~~
polygon.cpp:384:9: note: in expansion of macro 'FORR1'
  384 |         FORR1(adjlist[b].size()){
      |         ^~~~~
polygon.cpp: In function 'int query(vi, int)':
polygon.cpp:416:12: warning: value computed is not used [-Wunused-value]
  416 |         val-(1<<lsb(val));
      |         ~~~^~~~~~~~~~~~~~
polygon.cpp: In function 'bool gemacht(int, vi)':
polygon.cpp:448:1: warning: no return statement in function returning non-void [-Wreturn-type]
  448 | }
      | ^
/usr/lib/gcc/x86_64-linux-gnu/9/../../../x86_64-linux-gnu/crt1.o: In function `_start':
(.text+0x20): undefined reference to `main'
collect2: error: ld returned 1 exit status