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

VI dijkstra(VVI& graph, int v) {
    std::set<int> visited;
    VI rho(graph.size()); 
    VI pred(graph.size()); pred[v] = nil;
    
    for (VI::iterator itr = rho.begin(); itr != rho.end(); ++itr) {
        *itr = inf;
    }
    
    rho[v] = 0;
    
    int current_min_rho;
    while (visited.size() != graph.size()) {
        // travers
        current_min_rho = inf;
        for (int i = 0; i < graph.size(); ++i) {
            if (visited.find(i) == visited.end() && current_min_rho > rho[i])
                current_min_rho = i;
        }
        visited.insert(current_min_rho);
        
        // mark
        for (int i = 0; i < graph.size(); ++i) {
            if (graph[current_min_rho][i] && visited.find(i) == visited.end()) {
                if (rho[i] > rho[current_min_rho] + graph[current_min_rho][i]) {
                    rho[i] = rho[current_min_rho] + graph[current_min_rho][i];
                    pred[i] = current_min_rho;
                }
            }
        }
    }
    
    return rho;
}

    bool multi(VVI & x, VVI & y, VVI & z) {
        int mx = x.size();
        int my = y.size();
        if (mx == 0 || my == 0) return false;
        int nx = x[0].size();
        int ny = y[0].size();
        if (nx == 0 || ny == 0) return false;
        //cout << "mx: " << mx << endl;
        //cout << "my: " << my << endl;
        //cout << "nx: " << nx << endl;
        //cout << "ny: " << ny << endl;
        if (nx != my) return false;
       
        z.clear();
        for (int i = 0; i < mx; i++) {
            z.push_back(VI(ny, 0));
            for (int j = 0; j < ny; j++) {
                double sum = 0;
                for (int k = 0; k < my; k++) {
                    sum += (double)x[i][k] * (double)y[k][j];
                }

                if (sum > INT_MAX || sum < INT_MIN) return false;
                z[i][j] = (int)sum;
            }
        }
        return true;
    }

void CalcOmegaMatrix(const VVI & RM, const VVI & DM, VVI & OmegaM) {
	if (RM.size() == 0 || DM.size() == 0) {
		cerr << "Size of relation matrix and decison matrix is 0 !" << endl;
		exit(-1);
	}
	//OmegaM: n * d
	OmegaM.clear();
	VI viTmp(DM[0].size(), 0);
	OmegaM.insert(OmegaM.begin(), RM.size(), viTmp);

//	cout << OmegaM.size() << "\t" << OmegaM[0].size() <<endl;

	unsigned int i, j, k;
	STR2VI_MAP::iterator it;
	int sum = 0;

	for (i = 0; i < RM.size(); ++i) {
		for (j = 0; j < DM[0].size(); ++j) {
			sum = 0;
			for (k = 0; k < DM.size(); ++k) {
				sum += RM[i][k] * DM[k][j];
			}
			OmegaM[i][j] = sum;
		}
	}
}

void CalcH(const VVI OmegaM, const VI LM, VVD & H) {
	if (OmegaM.size() == 0 || LM.size() == 0) {
		cerr << "Size of Omega matrix or Lambda matrix is 0 !" << endl;
		exit(-1);
	}
	H.clear();
	VD vdTmp(OmegaM[0].size(), 0);
	H.insert(H.begin(), OmegaM.size(), vdTmp);

	unsigned int i, j;

	for (i = 0; i < H.size(); ++i)
		for (j = 0; j < H[0].size(); ++j) {
			H[i][j] = 1.0 * OmegaM[i][j] / LM[i];
		}
	/*
	 for(it=DMap.begin(), i=0; it!= DMap.end(); ++it, ++i)
	 {
	 for(j=0;j<RM.size();++j)
	 {
	 sum = 0;
	 for(k=0;k<(*it).second.size();++k)
	 {
	 sum += RM[j][(*it).second[k]];
	 }
	 H[i][j] = 1.0 * sum / LM [j];
	 }
	 }*/
}

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;
}

int BipartiteMatching(const VVI & w, VI & mr, VI & mc) {
  mr = VI(w.size(), -1);
  mc = VI(w[0].size(), -1);
  int ct = 0;
  for (int i = 0; i < w.size(); i++) {
    VI seen(w[0].size());
    if (FindMatch(i, w, mr, mc, seen)) ct++;
  }
  return ct;
}

 latin_square(const VVI& mat, const VI& rp, const VI& cp) : r(mat.size(), 0),
                                                            c(mat.size(), 0),
                                                            m(mat.size(), VI(mat.size())) {
   int n = mat.size();
   for (int i = 0; i < n; i++) {
     for (int j = 0; j < n; j++) {
       r[i] <<= 3;
       r[i] += mat[rp[i]][cp[j]];
       c[i] <<= 3;
       c[i] += mat[rp[j]][cp[i]];
       m[i][j] = mat[rp[i]][cp[j]];
     }
   }
 }

VVI mul(VVI a, VVI b) {
	int m = a.size();
	int n = a[0].size();
	int p = b.size();
	VVI c(m, VI(p, 0));
	for (int i = 0; i < m; i++) {
		for (int j = 0; j < p; j++) {
			for (int k = 0; k < n; k++) {
				c[i][j] += a[i][k] * b[k][j];
			}
			if (c[i][j] > 0) c[i][j] = 1;
		}
	}
	return c;
}

void display(VVI v){
	for(int i=0;i<v.size();i++){
		for(int j=0;j<v[i].size();j++)
			printf("%d ", v[i][j]);
		printf("\n");
	}
}

	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;
			}
		}
	}

void d1s1(VVI &inp){
    int vald1s1 = 0;
    int vald1s2 = 0;
    int vald2s1 = 0;
    int vald2s2 = 0;
    int n=inp.size();
    int n1 = n-1;
    int ij ;
    STACK stid1s1,stjd1s1;
    STACK stid1s2,stjd1s2;
    STACK stid2s1,stjd2s1;
    STACK stid2s2,stjd2s2;
    for(int i=0;i<n;i++){
        for(int j=0;j<=i;j++){
            ij = i-j;
            update(inp,stid1s1,stjd1s1,ij,j,vald1s1);
            if(i<(n1)){
               update(inp,stid1s2,stjd1s2,n1-j,n1-ij,vald1s2);
            }
            update(inp,stid2s1,stjd2s1,j,n1-ij,vald2s1);
            if(i<(n1)){
               update(inp,stid2s2,stjd2s2,n1-ij,j,vald2s2);
            }
        }
        emptyStacks(inp,stid1s1,stjd1s1,vald1s1);
        emptyStacks(inp,stid1s2,stjd1s2,vald1s2);
        emptyStacks(inp,stid2s1,stjd2s1,vald2s1);
        emptyStacks(inp,stid2s2,stjd2s2,vald2s2);
    }
}

/// Calc diagonal matrix Lambda
void CalcLambda(const VVI RM, VI & LM) {
	if (RM.size() == 0) {
		cerr << "Size of relation matrix!" << endl;
		exit(-1);
	}
	LM.clear();
	unsigned int i, j;
	int sum = 0;
	for (i = 0; i < RM.size(); ++i) {
		sum = 0;
		for (j = 0; j < RM[i].size(); ++j) {
			sum += RM[i][j];
		}
		LM.push_back(sum);
	}
}

pair<int, VI> GetMinCut(VVI &weights) {
    int N = weights.size();
    VI used(N), cut, best_cut;
    int best_weight = -1;
    
    for (int phase = N-1; phase >= 0; phase--) {
        VI w = weights[0];
        VI added = used;
        int prev, last = 0;
        for (int i = 0; i < phase; i++) {
            prev = last;
            last = -1;
            for (int j = 1; j < N; j++)
                if (!added[j] && (last == -1 || w[j] > w[last])) last = j;
            if (i == phase-1) {
                for (int j = 0; j < N; j++) weights[prev][j] += weights[last][j];
                for (int j = 0; j < N; j++) weights[j][prev] = weights[prev][j];
                used[last] = true;
                cut.push_back(last);
                if (best_weight == -1 || w[last] < best_weight) {
                    best_cut = cut;
                    best_weight = w[last];
                }
            } else {
                for (int j = 0; j < N; j++)
                    w[j] += weights[last][j];
                added[last] = true;
            }
        }
    }
    return make_pair(best_weight, best_cut);
}

int solve_impl(VVI &adj_list, int node, int k) {
  int N = adj_list.size();
  static VB visited(N);
  static VI fn(N), gn(N);

  // fn[i] contains no of subtrees rooted at i
  // gn[i] contains no of subtrees not rooted at i

  visited[node] = true;
  VI f_values, g_values;
  for (int i = 0; i < adj_list[node].size(); i++) {
    int child = adj_list[node][i];
    if (!visited[child]) {
      solve_impl(adj_list, child, k);
      f_values.push_back(fn[child]);
      g_values.push_back(gn[child]);
    }
  }
  fn[node] = max(subset_sum_count(f_values, k - 1) + 1, 1);
  gn[node] = 0;
  for (int i = 0; i < f_values.size(); i++) {
    gn[node] += f_values[i] + g_values[i];
  }
  cout << "fn and gn for " << node << " are " << fn[node] << " " << gn[node]
       << endl;
  return fn[node] + gn[node];
}

	void levelOrder(TreeNode* root, int iDeepth, VVI& result) {
		if (!root) return;
		if (iDeepth >= result.size())
			result.resize(iDeepth + 1);
		result[iDeepth].push_back(root->val);
		levelOrder(root->left, iDeepth + 1, result);
		levelOrder(root->right, iDeepth + 1, result);
	}