結果

問題 No.1647 Travel in Mitaru city 2
ユーザー むかでむかで
提出日時 2021-08-13 23:41:52
言語 C++17
(gcc 12.3.0 + boost 1.83.0)
結果
WA  
実行時間 -
コード長 6,036 bytes
コンパイル時間 2,598 ms
コンパイル使用メモリ 222,352 KB
実行使用メモリ 46,404 KB
最終ジャッジ日時 2024-10-04 00:01:15
合計ジャッジ時間 14,442 ms
ジャッジサーバーID
（参考情報） 		judge3 / judge1
このコードへのチャレンジ
（要ログイン）

テストケース

テストケース表示
入力 結果 実行時間
実行使用メモリ
testcase_00 AC 2 ms
5,248 KB
testcase_01 AC 2 ms
5,248 KB
testcase_02 AC 2 ms
5,248 KB
testcase_03 WA -
testcase_04 AC 4 ms
5,248 KB
testcase_05 AC 2 ms
5,248 KB
testcase_06 AC 2 ms
5,248 KB
testcase_07 WA -
testcase_08 AC 158 ms
41,020 KB
testcase_09 AC 158 ms
38,784 KB
testcase_10 AC 188 ms
41,360 KB
testcase_11 AC 163 ms
38,112 KB
testcase_12 WA -
testcase_13 WA -
testcase_14 AC 172 ms
42,288 KB
testcase_15 AC 158 ms
41,684 KB
testcase_16 AC 153 ms
39,628 KB
testcase_17 AC 157 ms
38,852 KB
testcase_18 WA -
testcase_19 AC 183 ms
41,656 KB
testcase_20 WA -
testcase_21 WA -
testcase_22 AC 199 ms
42,960 KB
testcase_23 AC 198 ms
43,232 KB
testcase_24 WA -
testcase_25 AC 181 ms
40,584 KB
testcase_26 AC 192 ms
42,980 KB
testcase_27 AC 207 ms
43,260 KB
testcase_28 AC 210 ms
43,896 KB
testcase_29 AC 193 ms
43,768 KB
testcase_30 AC 177 ms
37,712 KB
testcase_31 AC 184 ms
43,896 KB
testcase_32 AC 175 ms
39,808 KB
testcase_33 WA -
testcase_34 AC 193 ms
43,900 KB
testcase_35 AC 183 ms
41,216 KB
testcase_36 AC 208 ms
43,896 KB
testcase_37 AC 185 ms
43,848 KB
testcase_38 AC 168 ms
39,684 KB
testcase_39 WA -
testcase_40 AC 165 ms
39,472 KB
testcase_41 WA -
testcase_42 AC 159 ms
39,668 KB
testcase_43 AC 2 ms
5,248 KB
testcase_44 AC 6 ms
7,936 KB
testcase_45 WA -
testcase_46 AC 155 ms
30,984 KB
testcase_47 AC 138 ms
30,924 KB
testcase_48 AC 131 ms
30,976 KB
testcase_49 AC 129 ms
30,976 KB
testcase_50 WA -
権限があれば一括ダウンロードができます

ソースコード

diff # 

#include <bits/stdc++.h>

#define rep(i,n) for(int i=0;i<(int)(n);i++)
#define FOR(i,n,m) for(int i=(int)(n); i<=(int)(m); i++)
#define RFOR(i,n,m) for(int i=(int)(n); i>=(int)(m); i--)
#define ITR(x,c) for(__typeof(c.begin()) x=c.begin();x!=c.end();x++)
#define RITR(x,c) for(__typeof(c.rbegin()) x=c.rbegin();x!=c.rend();x++)
#define setp(n) fixed << setprecision(n)

template<class T> bool chmax(T &a, const T &b) { if (a<b) { a=b; return 1; } return 0; }
template<class T> bool chmin(T &a, const T &b) { if (a>b) { a=b; return 1; } return 0; }

#define ll long long
#define vll vector<ll>
#define vi vector<int>
#define pll pair<ll,ll>
#define pi pair<int,int>

#define all(a) (a.begin()),(a.end())
#define rall(a) (a.rbegin()),(a.rend())
#define fi first
#define se second
#define pb push_back
#define ins insert

#define debug(a) cerr<<(a)<<endl
#define dbrep(a,n) rep(_i,n) cerr<<(a[_i])<<" "; cerr<<endl
#define dbrep2(a,n,m) rep(_i,n){rep(_j,m) cerr<<(a[_i][_j])<<" "; cerr<<endl;}

using namespace std;

template<class A, class B>
ostream &operator<<(ostream &os, const pair<A,B> &p){return os<<"("<<p.fi<<","<<p.se<<")";}
template<class A, class B>
istream &operator>>(istream &is, pair<A,B> &p){return is>>p.fi>>p.se;}

template<class T>
vector<T> make_vec(size_t a){
	return vector<T>(a);
}
template<class T, class... Ts>
auto make_vec(size_t a, Ts... ts){
	return vector<decltype(make_vec<T>(ts...))>(a, make_vec<T>(ts...));
}

//-------------------------------------------------
//--Graph Template
//-------------------------------------------------
template<class E>
struct Graph
{
    vector<vector<E> > adj;
    Graph(int N):adj(N){}
    virtual void add_edge(int v, E e){adj[v].push_back(e);}
    vector<E>& operator[](int v){return adj[v];}
    inline int size(){return adj.size();}
};

namespace graph {
	struct SimpleEdge {
		int to;
		SimpleEdge(int to):to(to){}
	};
}

struct UWGraph : public Graph<graph::SimpleEdge>
{
    UWGraph(int N):Graph(N){}
    void add_edge(int v, int e){adj[v].push_back({e});}
};


//-------------------------------------------------
//--Get Cycle Any
//-------------------------------------------------
namespace Cycle
{
    stack<int> st;
    vector<bool> seen,finished;
    int pos;

    template<class E>
    void dfs(int v, int p, Graph<E> &G, bool dir=true){
        st.push(v);
        seen[v] = true;
        for(auto &e:G[v]){
            if (!dir && e.to==p) continue;
            if (finished[e.to]) continue;
            if (seen[e.to] && !finished[e.to]){
                pos = e.to;
                return;
            }
            dfs(e.to,v,G,dir);
            if (pos!=-1) return;
        }
        finished[v] = true;
        st.pop();
    }

    void init(int V){
        pos = -1; st=stack<int>();
        seen.resize(V,false);
        finished.resize(V,false);
    }

    vector<int> restore(){
        vector<int> ret;
        if (pos==-1) return ret;
        while(!st.empty()){
            int u = st.top(); st.pop();
            ret.push_back(u);
            if (u==pos) break;
        }
        reverse(ret.begin(),ret.end());
        return ret;
    }

    template<class E>
    vector<int> get(Graph<E> &G, bool dir=true){
        int V = G.size();
        init(V);
        for(int i=0;i<V;i++)if(!seen[i]){
            dfs(i,-1,G,dir);
            if (pos!=-1) break;
        }
        return restore();
    }

    template<class E>
    vector<int> get(int v, Graph<E> &G, bool dir=true){
        int V = G.size();
        init(V);
        dfs(v,-1,G,dir);
        return restore();
    }

    template<class E>
    vector<int> minimize(vector<int> &cycle, Graph<E> &G, bool dir=true){
        vector<int> ret;
        int L = cycle.size();
        if (L==0) return ret;
        unordered_map<int,int> Mp;
        for(int j=0;j<L;j++) Mp[cycle[j]]=j;
        int i=0;
        while(i<L){
            ret.push_back(cycle[i]);
            int ni=i;
            for(auto &e:G[cycle[i]]){
                if (!dir && i==0 && e.to==cycle[L-1]) continue;
                if (!dir && ret.size()<3 && e.to==cycle[0]) continue;
                if (e.to==cycle[0]){
                    ni=L;
                    break;
                }else{
                    chmax(ni,Mp[e.to]);
                }
            }
            i=ni;
        }
        return ret;
    }
}

//-------------------------------------------------

int main(void)
{
    cin.tie(0);
    ios::sync_with_stdio(false);
	int H,W,N; cin>>H>>W>>N;

	vector<vi> row(H), col(W);
	rep(i,N){
		int y,x; cin>>y>>x; y--; x--;
		row[y].pb(i);
		col[x].pb(i);
	}

	UWGraph G(4*N);
	rep(i,H){
		auto &vec = row[i];
		int sz = vec.size();
		rep(j,sz-1){
			int from = vec[j];
			int to = vec[j+1];
			G.add_edge(from,to);
		}
		rep(j,sz-1){
			int from = vec[j+1] + N;
			int to = vec[j] + N;
			G.add_edge(from,to);
		}
		rep(j,sz-1){
			int from = vec[j] + 2*N;
			int to = vec[j+1];
			G.add_edge(from,to);
			from = vec[j] + 3*N;
			G.add_edge(from,to);
		}
		rep(j,sz-1){
			int from = vec[j+1] + 2*N;
			int to = vec[j] + N;
			G.add_edge(from,to);
			from = vec[j+1] + 3*N;
			G.add_edge(from,to);
		}
	}

	rep(i,W){
		auto &vec = col[i];
		int sz = vec.size();
		rep(j,sz-1){
			int from = vec[j] + 2*N;
			int to = vec[j+1] + 2*N;
			G.add_edge(from,to);
		}
		rep(j,sz-1){
			int from = vec[j+1] + 3*N;
			int to = vec[j] + 3*N;
			G.add_edge(from,to);
		}
		rep(j,sz-1){
			int from = vec[j];
			int to = vec[j+1] + 2*N;
			G.add_edge(from,to);
			from = vec[j] + N;
			G.add_edge(from,to);
		}
		rep(j,sz-1){
			int from = vec[j+1];
			int to = vec[j] + 3*N;
			G.add_edge(from,to);
			from = vec[j+1] + N;
			G.add_edge(from,to);
		}
	}
	
	auto cycle = Cycle::get(G);
	if (cycle.empty()){
		cout<<"-1\n";
	}else{
		int sz = cycle.size();
		vi ans;
		rep(i,sz){
			if (i < sz-1){
				int v1 = cycle[i]/N;
				int v2 = cycle[i+1]/N;
				if (v1 == v2) continue;
			}
			ans.pb(cycle[i]%N+1);
		}
		int V = ans.size();
		cout<<V<<"\n";
		rep(i,V) cout<<ans[i]<<" \n"[i==V-1];
	}

    return 0;
}
0