C++ VVI::back方法代码示例

	void initDfs(int u,int level = 0)
	{
		LVL[u] = level;
		SZ[u] = 1;
		for(int i = 0; i < adj[u].size(); ++i)
		{
			int v = adj[u][i];
			if(SZ[v])continue;
			P[v] = u;
			initDfs(v,level + 1);
			SZ[u] += SZ[v];
		}
		for(int i = 0; i < adj[u].size(); ++i)
		{
			int v = adj[u][i];
			if(v == P[u])continue;
			if(2*SZ[v] > SZ[u]-1){
				PC[u] = v;
			}
			else
			{
				groups.push_back(VI());
				for(int j = v; j != -1; j = PC[j])
					groups.back().push_back(j) ,
					groupId[j] = groups.size() - 1 ,
					groupPos[j] = groups.back().size()-1;
			}
		}
	}

VVI exactify(const VVI& S, const int N) {
	VVI vec;
    for(int r = 0; r < N; ++r) {
        for(int c = 0; c < N; ++c) {
        	for(int cand = 0; cand < N; ++cand) {
        		if(S[r][c] != 0 && S[r][c] != cand + 1) {
                    continue;
                }

        		row_cand[vec.size()] = r*N*N + c*N + cand;

        		vector<int> L(4*N*N);
        		vec.push_back(L);

                
                int reg = region(r,c,N);
                vec.back()[r*N + c] = 1;
                vec.back()[N*N + r*N + cand] = 1;
                vec.back()[2*N*N + N*c + cand] = 1;
                vec.back()[3*N*N + N*reg + cand] = 1;
            }
        }
    }
    
    if(!given_solution.empty()) {
    	map<int,int> rev;
        map<int,int>::iterator it;
        for(it = row_cand.begin(); it != row_cand.end(); ++it) {
            rev[it->second] = it->first;
        }

        vector<int> check(vec[0].size());

        for(int x = 0; x < given_solution.size(); ++x) {
            for(int y = 0; y < given_solution[x].size(); ++y) {
                int val = x * N * N + y * N + given_solution[x][y] - 1;
                for(int i = 0; i < vec[rev[val]].size(); ++i) {
                    check[i] += vec[rev[val]][i];
                }
            }
        }

        for(int i = 0; i < check.size(); ++i) {
            assert(check[i] == 1);
        }

    }

    return vec;
}

string moreClasses(string a, vector <string> b) {
  int i, j, k, x, y, z, n;
  string ret = "";
  VVI m;

  for( i = 0; i < b.size(); i++ ) {
    n = atoi(b[i].c_str());
    for( j = 0; j < n; j++ ) {
      m.push_back(VI());
      for( k = 0; k < b[i].size(); k++ ) if( !isdigit(b[i][k]) )
        m.back().push_back(b[i][k]);
    }
  }
  if( m.size() > 128 ) return "0";
  for( i = 0; i < a.size(); i++ ) taken[a[i]] = 1;
  n = m.size()-bipartitematch(m);
  x = 33;
  while( n ) {
    if( x >= 128 ) return "0";
    if( taken[x] ) {x++; continue;}
    taken[x] = 1;
    if (x >= 67)
	    cout<<x;
    z = m.size()-bipartitematch(m);
    if( z == n )
      taken[x] = 0;
    else
      ret += x;
    n = z;
    x++;
  }
  return ret;
}

	HLD(VVI adj) {
		N = adj.size();
		P = PC = VI(N , -1);
		LVL = SZ = groupId = groupPos = VI(N , 0);
		this->adj = adj;
		for(int i = 0; i < N; ++i)
		{
			if(SZ[i] == 0)
			{
				initDfs(i);
				groups.push_back(VI());
				for(int j = i; j != -1; j = PC[j])
					groups.back().push_back(j) ,
					groupId[j] = groups.size() - 1 ,
					groupPos[j] = groups.back().size()-1;
			}
		}
	}

    int DFS (PI v, int index) {
        idx[v.x] = index;
        low[v.x] = index;
        index += 1;

        int children = 0;
        bool ap = false;
        for (auto w : adj[v.x]) if (w.y != v.y) {
                if (idx[w.x] == -1) {
                    st.push_back(w.y);
                    index = DFS(w, index);
                    low[v.x] = min(low[v.x], low[w.x]);
                    if (low[w.x] > idx[v.x]) {
                        bridges.push_back(w.y);
                    }
                    children++;
                    if (low[w.x] >= idx[v.x]) {
                        if (v.y != -1 || children >= 2) {
                            ap = true;
                        }
                        components.push_back(VI());
                        totalComponents++;
                        int u;
                        do {
                            u = st.back();
                            st.pop_back();
                            components.back().push_back(u);
                        } while (u != w.y);
                    }
                } else if (idx[w.x] < idx[v.x]) {
                    st.push_back(w.y);
                    low[v.x] = min(low[v.x], idx[w.x]);
                }
            }
        if (ap) {
            cutVertices.push_back(v.x);
        }
        return index;
    }

int calc(const VI& in)
{
    VVI vals;

    // memo
    for(int i=0;;i++)
    {
        vals.pb(VI(words.size(),1));
        bool found = false;
        for(int j=0;j<in.size();j++) if(in[j] == i)
        {
            found = true;
            for(int k=0;k<words.size();k++)
            {
                vals.back()[k] *= words[k][equation[j]];
                vals.back()[k] %= MOD;
            }
        }
        if(found == false) 
        {
            vals.pop_back();
            break;
        }
    }

    int mul = 1;
    for(int i=0;i<vals.size();i++)
    {
        int sum = 0;
        for(int j=0;j<vals[i].size();j++)
            sum += vals[i][j];
        sum %= MOD;

        mul = (mul * sum) % MOD;
    }

    return mul;
}

void exact(VVI v) {
	if(v.size() == 0) {
		if(selected < glob[0].size() - 1) return;
		set<int> newelem;
		for(int i = 0; i < sol.size(); ++i) {
            newelem.insert(sol[i]);
        }
        sols.insert(newelem);
        /*
		cout<<"Solution:"<<endl;
        vector<int> sum(glob[0].size() - 1);
		for(int i = 0; i < sol.size(); ++i) {
            cout<<sol[i]<<endl;
            for(int j = 0; j < glob[sol[i]].size() - 1; ++j) {
                sum[j] += glob[sol[i]][j];
            }
        }
        for(int i = 0; i < sum.size(); ++i) {
            cout<<sum[i]<<" ";
        }
        cout<<endl;
        cout<<"---------"<<endl;
        */
        return;
    }

    for(int r = 0; r < v.size(); ++r) {
        if(v[r][0] == 1) {
            set<int> dc;
            set<int> dr;
            for(int j = 0; j < v[r].size() - 1; ++j) {
                if(v[r][j]) {
                    for(int i = 0; i < v.size(); ++i) {
                        if(v[i][j]) {
                            dr.insert(i);
                        }
                    }
                    dc.insert(j);
                }
            }

            /*
               set<int>::iterator it;
               cout<<"Banned columns: "<<endl;
               for(it = dc.begin(); it != dc.end(); ++it) {
               cout<<*it<<" ";
               }
               cout<<endl;
               cout<<"Banned rows: "<<endl;
               for(it = dr.begin(); it != dr.end(); ++it) {
               cout<<*it<<" ";
               }
               cout<<endl;
             */

            /*
               for(int i = 0; i < v[r].size() - 1; ++i) {
               if(v[r][i]) {
               dc.insert(i);
               for(int j = 0; j < v.size(); ++j) {
               if(v[j][i]) dr.insert(j);
               }
               }
               }
             */

            VVI nv;

            for(int i = 0; i < v.size(); ++i) {
                if(dr.count(i)) continue;
                nv.resize(nv.size() + 1);
                for(int j = 0; j < v[i].size(); ++j) {
                    if(!dc.count(j)) {
                        nv.back().push_back(v[i][j]);
                    }
                }
            }


            /*
               print(v);
               cout<<"Removing row "<<r<<endl;
               print(nv);
             */

            int sel = 0;
            for(int i = 0; i < v[r].size() - 1; ++i) {
                if(v[r][i]) ++sel;
            }

            selected += sel;
            sol.push_back(v[r].back());
            exact(nv);
            sol.pop_back();
            selected -= sel;
        }
    }
}