Beispiel #1
0
int main()
{
    //freopen("PAT1038.input", "r", stdin);

    int N;
    string a;
    cin >> N;
    for (int i = 0; i < N; i++)
    {
        cin >> a;
        int tmp = a.size();
        a.resize(8);
        for (int i = tmp; i < 8; i++)
            a[i] = a[i-tmp];
        que.push(MyString(a, tmp));
    }

    bool first = true;
    while (!que.empty())
    {
        MyString a = que.top();
        que.pop();

        if (first)
        {
            // 陷阱:数字为0
            int start = 0;
            for (int i = 0; i < a.len; i++)
                if (a.data[i] == '0')
                    start++;
                else
                    break;
            if (start == a.len)
                continue;
            a.len -= start;
            first = false;
            cout << a.data.substr(start, a.len);
        }
        else
            cout << a.data.substr(0, a.len);
    }
    // 陷阱:如果所有数为0
    if (first)
        cout << 0;
    cout << endl;
}
/**
 * @brief Return to the client the found results.
 * @param rankedResults the ranked list of results.
 * @param req the received search request.
 * @param i_maxNbResults the maximum number of results returned.
 */
void ORBSearcher::returnResults(priority_queue<SearchResult> &rankedResults,
                                  SearchRequest &req, unsigned i_maxNbResults)
{
    list<u_int32_t> imageIds;

    unsigned i_res = 0;
    while(!rankedResults.empty()
          && i_res < i_maxNbResults)
    {
        const SearchResult &res = rankedResults.top();
        imageIds.push_back(res.i_imageId);
        i_res++;
        cout << "Id: " << res.i_imageId << ", score: " << res.f_weight << endl;
        req.results.push_back(res.i_imageId);
        rankedResults.pop();
    }
}
int main()
{
  int n, m;

  while(cin >> m >> n) {
    if(n == 0 && m == 0) return 0;
    adjlist.clear(); adjlist.resize(n);

    int current = 0;
    for(size_t i = 0; i < n; ++i) {
      int x,y,z; cin >> x >> y >> z;
      current += z;

      adjlist[x].push_back(pair<int, int> (y, z));
      adjlist[y].push_back(pair<int, int> (x, z));
    }

    taken.clear();
    taken.resize(n, 0);
    proccess(0);
    int min_cost = 0;

    while(!pq.empty()) {
      pair<int, int> front = pq.top(); pq.pop();
      int u = -front.second; // vertex
      int w = -front.first; // weight

      if(!taken[u]) {
        min_cost += w;

        taken[u] = 1;
        for(int j = 0; j < adjlist[u].size(); ++j) {
          pair<int, int> v = adjlist[u][j];

          if(!taken[v.first])
            pq.push(pair<int, int>(-v.second, -v.first)); // negate to handle negatives
        }
      }
    }

    cout << current - min_cost << endl;
  }

  return 0;
}
int main()
{
    while(scanf("%d %d",&n,&m)!=EOF)
    {
    int i;
    for(memset(deg,0,sizeof(deg)) , i=0;i<m;i++)
    {
        scanf("%d %d %d",&li[i][0],&li[i][1],&li[i][2]);
        li[i][0]--;li[i][1]--; deg[li[i][0]]++; deg[li[i][1]]++;
    }
    for( i=0;i<n;e[i] = new(int[deg[i]]),c[i] = new(int[deg[i]]),deg[i]=0,i++);
    for( i=0;i<m;i++)
    {
        e[li[i][0]][deg[li[i][0]]]=li[i][1];
        c[li[i][0]][deg[li[i][0]]]=li[i][2];
        deg[li[i][0]]++;
        e[li[i][1]][deg[li[i][1]]]=li[i][0];
        c[li[i][1]][deg[li[i][1]]]=li[i][2];
        deg[li[i][1]]++;
    }
    struct dat dat2;
    dat2.p=0;dat2.dis=0;
    q.push(dat2);
    int p,d;
    for(memset(t,0,sizeof(t));!q.empty();q.pop())
    {
        p = q.top().p;
        d=q.top().dis;
        if(t[p]<2)
        {
            ans[p][t[p]]=d; t[p]++;
            for(i=0;i<deg[p];i++)
            {
                if(t[e[p][i]]<2)
                {
                    struct dat dat1 ;
                    dat1.p= e[p][i]; dat1.dis = d + c[p][i];
                    q.push(dat1);
                }
            }
        }
    }
    printf("%d\n",ans[n-1][1]);
    }
}
int main ()
{
	int C, V, i, j, dest;
	int u, v;
	int C1, C2, G;
	cin >> C >> V;
	edge.clear();
	edge.resize(2*C);
	for (i = 0; i < V; i++)
	{
		cin >> C1 >> C2 >> G;
		C1 = 2*(C1-1);
		C2 = 2*(C2-1);
		edge[C1].push_back(make_pair(C2+1,G));
		edge[C2+1].push_back(make_pair(C1,G));
		edge[C1+1].push_back(make_pair(C2,G));
		edge[C2].push_back(make_pair(C1+1,G));
	}
	int dist[2*C];
	dest = 2*C - 2;
	for (i = 0; i < 2*C; i++)
		dist[i] = INF;
	dist[0] = 0;
	q.push(make_pair(0,0));
	while (!q.empty())
	{
		u = q.top().first;
		q.pop();
		int size = edge[u].size();
		for (v = 0; v < size; v++)
		{
			int vv = edge[u][v].first;
			int w = edge[u][v].second;
			if (dist[u] + w < dist[vv])
			{
				dist[vv] = dist[u] + w;
				q.push(make_pair(vv,dist[vv]));
			}	
		}	
	}
	if (dist[dest] == INF)
		cout << -1 << endl;
	else
		cout << dist[dest] << endl;
}
Beispiel #6
0
void Dijkstra(int src) {
	dist = vector<int>(V+1, INF);
	dist[src] = 0;
	pq.push(make_pair(0, 1));
	while (!pq.empty()) {
		int cost = -pq.top().first;
		int u = pq.top().second;
		pq.pop();
		if (cost > dist[u]) continue;
		for (int i=0; i<adj[u].size(); ++i) {
			int v = adj[u][i].first;
			if (dist[v] > dist[u]+adj[u][i].second) {
				dist[v] = dist[u]+adj[u][i].second;
				pq.push(make_pair(-dist[v], v));
			}
		}
	}
}
Beispiel #7
0
double kruskall(int n) {
	union_find ufds(n);
	double mst_cost = 0.0;
	while(not edges.empty()) {
		auto current_edge = edges.top();
		double w = current_edge.first;
		int u = current_edge.second.first, v = current_edge.second.second;

		if(not ufds.same_set(u, v)) {
			ufds.union_set(u, v);
			mst_cost += w;
		}

		edges.pop();
	}

	return mst_cost;
}
Beispiel #8
0
int prim()
{
    int ans = 0;
    vector<Edge> mst;
    visit(1);
    while (!pq.empty() && mst.size()<N-1)
    {
        Edge e = pq.top();
        pq.pop();
        int u = e.either, v = e.other;
        if (mark[u] && mark[v]) continue;
        mst.push_back(e);
        ans += e.weight;
        if (!mark[u]) visit(u);
        if (!mark[v]) visit(v);
    }
    return ans;
}
Beispiel #9
0
void search(){
    for(int x = 0;x<MAX;x++) dist[x] = LARGE;
    dist[1] = 0;
    q.push(pii(0,1));
    while(!q.empty()){
        pii cur = q.top();
        q.pop();
        if(vis[cur.B]) continue;
        vis[cur.B] = true;
        for(vi it = list[cur.B].begin();it!=list[cur.B].end();++it){
            if(dist[it->B]>dist[cur.B]+it->A){
                pre[it->B] = cur.B;
                dist[it->B] = dist[cur.B]+it->A;
                q.push(pii(dist[it->B],it->B));
            }
        }
    }
}
Beispiel #10
0
int solve(priority_queue<int>& votes, int m) {
	int count, n;

	count = 0;
	while (votes.size() > 0) {
		n = votes.top();
		votes.pop();

		if (n < m) break;

		votes.push(--n);

		m++;
		count++;
	}

	return count;
}
Beispiel #11
0
int main(void) {
  string s;
  int q, p, k;
  
  while(cin >> s, s!="#") {
    cin >> q >> p;
    Q.push(Item(q, p));      
  }
  
  cin >> k;
  for(int i=0; i<k; ++i) {
    Item item = Q.top(); Q.pop();
    cout << item.q << endl;
    Q.push(item.next());
  }

  return 0;
}
Beispiel #12
0
	double dijkstra(int st, int ed) {
		for (int i = 0; i < n; i++)
			dis[i] = inf, vis[i] = false;
		dis[st] = 0;
		q.push(MP(0.0, st));
		while (!q.empty()) {
			int u = q.top().second; q.pop();
			vis[u] = true;
			for (int i = last[u]; ~i; i = prev[i]) {
				int v = to[i];
				if (!vis[v] && sig(dis[v] - (dis[u] + len[i])) > 0) {
					dis[v] = dis[u] + len[i];
					q.push(MP(-dis[v], v));
				}
			}
		}
		return dis[ed];
	}
void dijkstra(){
    int u, v, d1, d2, currStatus;
    u = 0,  d1 = 0, currStatus = walk;
    dist[currStatus][0] = 0;
    pq.push(iii(dist[currStatus][0], 0, currStatus));

    while(!pq.empty()){
        tie(d1, u, currStatus) = pq.top();   pq.pop();
        if(d1 > dist[currStatus][u])    continue;
        for(int i = 0; i < AdjList[u].size(); ++i){
            v = AdjList[u][i].first,    d2 = AdjList[u][i].second;
            if(d1 + d2 < dist[1 - currStatus][v]){
                dist[1 - currStatus][v] = d1 + d2;
                pq.push(iii(dist[1 - currStatus][v], v, 1 - currStatus));
            }
        }
    }
}
void dijkstra(int source, vector<int> &dist, vector< vector< ii > > &AdjList){
    dist[source] = 0;
    pq.push(ii(dist[source], source));

    int u, v, d1, d2;
    while(!pq.empty()){
        u = pq.top().second;    d1 = pq.top().first;
        pq.pop();
        if(d1 > dist[u])    continue;
        for(int i = 0; i < AdjList[u].size(); ++i){
            v = AdjList[u][i].first;    d2 = AdjList[u][i].second;
            if(d1 + d2 < dist[v]){
                dist[v] = d1 + d2;
                pq.push(ii(dist[v], v));
            }
        }
    }
}
Beispiel #15
0
int main(int argc, char *argv[])
{
    scanf("%d%d%d",&n,&e,&k);
    for(int i = 1;i<=k;i++)
     scanf("%d%d%d",&h[i].x,&h[i].f,&h[i].c);
    sort(h+1,h+k+1);
    st s;
    s.i = 0;s.key = 0;s.n = 0;
    q.push(s);
    for(int i = 1;i<=k;i++)
    {
     while(!q.empty() && q.top().i < i-1)
      q.pop();
     
    }
    system("PAUSE");
    return EXIT_SUCCESS;
}
Beispiel #16
0
 void operator()(strings::UniString const & s, trie::ValueReader::ValueType const &)
 {
   if (m_currentS == s)
   {
     ++m_currentCount;
   }
   else
   {
     if (m_currentCount > 0)
     {
       tokens.push(make_pair(m_currentCount, m_currentS));
       if (tokens.size() > 100)
         tokens.pop();
     }
     m_currentS = s;
     m_currentCount = 0;
   }
 }
Beispiel #17
0
LL dijkstra(int st, int ed, int n) {
    int i;
    ele tn(0,0);
    while(!pQ.empty()) {
        tn = pQ.top();
        pQ.pop();
        if(used[tn.nd] || dis[tn.nd] >= dis[ed]) continue;
        used[tn.nd] = 1;
        for(it i = g[tn.nd].begin();
            i != g[tn.nd].end(); i++) {
            if(dis[i->to] > dis[tn.nd] + i->w) {
                dis[i->to] = dis[tn.nd] + i->w;
                pQ.push(ele(i->to, dis[i->to]));
            }
        }
    }
    return dis[ed];
}
int main(){
  int t,i,j;
  while(~scanf("%d",&t)){
    while(t--){
      while(!q.empty())q.pop();
      scanf("%d%d",&n,&m);
      for(i=0;i<n;++i)
        for(j=0;j<m;++j){
          scanf("%d",&mp[i][j]);
          pre[Num(i,j)]=Num(i,j);
          q.push(node(i,j));
        }
      scanf("%d",&y);
      for(i=y;i;--i)scanf("%d",sea+i);
      bfs();
    }
  }
}
Beispiel #19
0
int main()
{
    scanf("%d",&T);
    while(T--)
    {
        scanf("%d%d",&N,&M);
        for(int i=0;i<=N;i++)G[i].clear(),deg[i]=allocated[i]=0;
        for(int i=0;i<M;i++)
        {
            int u,v;
            scanf("%d%d",&u,&v);
            G[u].push_back(v);
            G[v].push_back(u);
            deg[u]++;
            deg[v]++;
        }
        int ans1=0;
        for(int i=0;i<N;i++)
        {
            int t=0;
            for(int j=0;j<G[i].size();j++)
            {
                if(G[i][j]>i)t++;
            }
            ans1=max(ans1,t);
            Q.push((Node){deg[i],i});
        }
        int ans2=0;
        while(!Q.empty())
        {
            Node x=Q.top();Q.pop();
            if(allocated[x.id]){continue;}
            ans2=max(ans2,x.deg);
            allocated[x.id]=1;
            for(int i=0;i<G[x.id].size();i++)
            {
                deg[G[x.id][i]]--;
                Q.push((Node){deg[G[x.id][i]],G[x.id][i]});
            }
        }
        printf("%d %d\n",ans1,ans2);
    }
    return 0;
}
Beispiel #20
0
int main(){
    int n;
    cin >> n;
    for(int i = 0; i < 100; i++){
        for (int j = 0; j < 100; ++j) {
            mat[i][j] = INT_MAX;
        }
    }
    for (int i = 0; i < 100; ++i) {
        discnt[i] = INT_MAX;
    }
    for(int i = 0; i < n; i++){
        char a, b;
        int c;
        scanf(" %c %c %d", &a, &b, &c);
        if(a == b) continue;
        mat[a-'A'][b-'A'] = min(mat[a-'A'][b-'A'], c);
        mat[b-'A'][a-'A'] = min(mat[b-'A'][a-'A'], c);
    }
    for(int i = 0; i < 100; i++){
        if(mat['Z'-'A'][i] != INT_MAX){
            pq.push(vetice(i,mat['Z'-'A'][i]));
        }
    }
    while(!pq.empty()){
        int x = pq.top().n;
        int dis = pq.top().distance;
        discnt[x] = dis;
        pq.pop();

        if(x + 'A' >= 'A' && x + 'A' < 'Z'){
            cout << char(x+'A') << " " << dis << endl;
            return 0;
        }

        for(int i = 0; i < 100; i++){
            if(mat[x][i] != INT_MAX){
                if(dis+mat[x][i] < discnt[i])
                    pq.push(vetice(i,dis+mat[x][i]));
            }
        }
    }
    return 0;
}
int main() {
  int n;
  cin >> n;
  for (int i = 0; i < n; ++i) {
    int V, C;
    cin >> V >> C;

    vii inside(V, pair<int, int>(0, 0));
    AdjList.assign(V, inside);
    for (int j = 0; j < C; ++j) {
      int x, y, z;
      cin >> x >> y >> z;
      ii one(y, z);
      ii two(x, z);
      if (one.second > AdjList[x][y].second) {
	AdjList[x][y] = one;
	AdjList[y][x] = two;
      }

    }

    
    int mst_cost, u, w;
    taken.assign(V, 0);
    process(0); // Take vertex 0 and process all edges incident to vertex 0
    mst_cost = 0;

    int minCapacity = 2147383647;
    while (!pq.empty()) { // repeat until V vertices (E=V-1) edges are taken
      ii front = pq.top(); pq.pop();
      u = -front.second, w = -front.first; // negate the id and weight again
      if (!taken[u]) {
	//mst_cost += w, process(u); // Each edge is in pq only one
	if (w < minCapacity) minCapacity = w;
	process(u);
      }
    }
    // Print Cost
    cout << "Case #" << i + 1 << ": " << minCapacity << endl;
    pq = priority_queue<ii, vector<ii>, std::greater<ii> >();
    taken.clear();
    AdjList.clear();
  }
}
    // Fetch several files to merge. The number of files is passed in.
    vector<string> GetFiles(int n)
    {
        boost::mutex::scoped_lock scoped_lock(mutex_);

        if (astFiles_.size() < 2) return vector<string>();

        vector<string> files;
        for (int i = 0; i < n; ++i)
        {
            if (!astFiles_.empty())
            {
                string filename = astFiles_.top();
                astFiles_.pop();
                files.push_back(filename);
            }
        }
        files.push_back(GetOutputFileName());
        return files;
    }
int Prim(int u)
{
    int mst=0;
    process(u);
    while(!pq.empty()){
        edge e = pq.top();
        pq.pop();
        if(!visited[e.to]){
            process(e.to);
            if(e.w >= A){
                connectA++;
                mst += A;
            }
            else  
                mst += e.w;
        }
    }
    return mst;
}
Beispiel #24
0
void topological_sort(){
 
    for (int i = 1; i <= N; i++)
        if (ind[i] == 0)
            q.push(-i);
 
    for (int k = 0; k < N; k++){
        int here = -q.top();
        q.pop();
        printf("%d ", here);
        for (int i = 0; i < adj[here].size(); i++){
            int there = adj[here][i];
            ind[there]--;
            if (ind[there] == 0)
                q.push(-there);
        }
    }
 
}
Beispiel #25
0
void dijkstra(int S){
	int u, v, i;
	cost[S] = 0;
	pi[S] = -1;
	q.push(S);
	while(!q.empty()){
		u = q.top();
		for(i=0; i<edge[u].size(); i++){
			v = edge[u][i];
			if(seen[u][v] == cs)continue;
			if(cost[v] > wght[u][v] + cost[u]){
				cost[v] = wght[u][v] + cost[u];
				pi[v] = u;
				q.push(v);
			}
		}
		q.pop();
	}
}
Beispiel #26
0
int main()
{
    int T;
    scanf("%d", &T);
    while(T--)
    {
        scanf("%d", &n);
        init();
        for(int i=1; i<=n; i++) scanf("%d", l+i);
        for(int i=1; i<=n; i++) scanf("%d", r+i);
        for(int i=1; i<=n; i++) scanf("%d", c+i);

        d[1]=c[1];
        q.push(mp(d[1], 1));
        while(!q.empty())
        {
            int u=q.top().snd;
            q.pop();
            for(int i=-1; i<=1; i+=2)
            {
                int L=l[u]*i+u;
                int R=r[u]*i+u;
                if(L>R)swap(L, R);
                L=max(L, 1);
                L=min(L, n+1);
                for(int v=L; ; v++)
                {
                    v=find(v);
                    if(v>n || v>R)break;
                    if(d[v]>d[u]+c[v])
                    {
                        d[v]=d[u]+c[v];
                        q.push(mp(d[v], v));
                    }
                    fa[find(v)]=find(v+1);
                }
            }
        }
        for(int i=1; i<=n; i++)
            printf("%I64d%c", d[i]==oo?-1:d[i]-c[i], " \n"[i==n]);
    }
    return 0;
}
void dijkstra( int source, int w ){
  dist[source] = 0;
  Q.push( Node( source, w ) );

  while ( !Q.empty() ){
    int actual = Q.top().first;
    Q.pop();
    if ( visit[actual] ) continue;
    visit[actual] = true;

    for ( int i = 0; i < ady[actual].size(); i++ ){
      int adyacente = ady[actual][i].first;
      int peso = ady[actual][i].second;
      if ( !visit[adyacente] ){
        relax( actual, adyacente, peso );
      }
    }
  }
}
int main() {
    
    string  str;
    
    int     id, val;
    
    while( ( cin >> str ) && str != "#" ) {
        cin >> id >> val;
        M[id] = val;
        Q.push( Data( id, val ) );
    }
    
    for( cin >> val; val--; ) {
        cout << Q.top().id << endl;
        Q.push( Data( Q.top().id, Q.top().t + M[Q.top().id] ) );
        Q.pop();
    }
    
}
Beispiel #29
0
void dijkstra(int start){
    dist[start]=0;
    pq.push(make_pair(0,start)); // pair<거리,노드> 거리가 작은 순서대로 정렬
    while(!pq.empty()){
        pair < int , int > tmp = pq.top();
        pq.pop();
        int c= tmp.second;
        if(visited[c] == 1)
            continue;
        visited[c]=1;
        for(int j=0; j<v[c].size(); j++){
            int n=v[c][j].first;
            if(dist[n] > dist[c] + v[c][j].second){
                dist[n]=dist[c] + v[c][j].second;
                pq.push(make_pair(-dist[n],n));//max_heap에 넣으니까.
            }
        }
    }
}
int main() {
	int m, n, i;
	scanf("%d", &m);
	for (i = 0; i < m; ++i) {
		int x;
		scanf("%d", &x);
		op[i] = x;
		if (x == 1) scanf("%d", l + i);
		else scanf("%d %d", l + i, c + i);
	}
	scanf("%d", &n);
	for (i = 0; i < n; ++i) scanf("%I64d", a + i), --a[i], q.push({a[i], i});

	long long sz = 0;
	for (i = 0; i < m; ++i) {
		if (op[i] == 1) {
			memo[sz] = l[i], ++sz;
		} else {
			v.push_back({sz - 1, l[i]});
			if (sz + 1LL * l[i] * c[i] > a[n - 1]) break;
			sz += 1LL * l[i] * c[i];
		}
	}

	while (true) {
		while (!q.empty() && memo.count(q.top().first)) ans[q.top().second] = memo[q.top().first], q.pop();
		if (q.empty()) break;
		while (q.top().first > v.back().first) {
			long long x = q.top().first;
			i = q.top().second, q.pop();
			x = (x - v.back().first - 1) % v.back().second;
			q.push({x, i});
		}
		v.pop_back();
	}

	for (i = 0; i < n; ++i) {
		if (i) putchar(' ');
		printf("%d", ans[i]);
	}
	puts("");
	return 0;
}