HDOJ 3342 拓扑排序

本文通过一个具体的编程问题,展示了如何从使用数组模拟的树状结构优化到邻接表实现,显著提升了拓扑排序算法的效率,从最初的200ms降低到了31ms。

摘要生成于 C知道 ,由 DeepSeek-R1 满血版支持, 前往体验 >

题目:http://acm.hdu.edu.cn/showproblem.php?pid=3342

题意:判断有无环

#include<bits/stdc++.h>
#define INF 1e18
#define inf 1e9
#define min(a,b) a<b?a:b
#define max(a,b) a>b?a:b
#define lson l,m,rt<<1
#define rson m+1,r,rt<<1|1
#define IOS ios_base::sync_with_stdio(false),cin.tie(0),cout.tie(0)
using namespace std ;
typedef long long ll;
typedef unsigned long long ull;
const ll _max = 505;
int n,m;
int mp[_max][_max];
int ft[_max];

void topsort(){
    priority_queue<int,vector<int>,greater<int> > q;
    while(!q.empty()) q.pop();
    int cnt = 0;
    for(int i = 0 ; i < n ; i++){
        if(!ft[i]){
            q.push(i);
            cnt++;
        }   
    }
    int id = 0;
    while(!q.empty()){
        id = q.top();
        q.pop();
        for(int i = 0 ; i < n ; i++){
            if(mp[id][i]){
                ft[i]--;
                if(!ft[i]){
                    q.push(i);
                    cnt++;
                }   
            }       
        }
    }
    if(cnt == n) cout<<"YES"<<endl;
    else cout<<"NO"<<endl; 
    return ;
}
int main(){
    IOS;
    while(cin>>n>>m){
        if(!n&&!m) break;
        memset(mp,0,sizeof(mp));
        memset(ft,0,sizeof(ft));
        int u,v;
        for(int i = 1 ; i <= m ; i++){
            cin>>u>>v;
            if(!mp[u][v]){
                mp[u][v] = 1;
                ++ft[v];
            }
        }
        topsort();
    }
    return 0;
}

这是最开始的代码,就直接判断用队列排进多少节点,然后和n进行对比。就知道有没有环了,因为拓扑排序里,有环是排不进的。但是太慢了200ms,我看了下别人是0ms的。
然后看了下代码,我这里时间久应该是因为我用数组模拟的树状结构。所以慢,所以换成邻接表。

#include<bits/stdc++.h>
#define INF 1e18
#define inf 1e9
#define min(a,b) a<b?a:b
#define max(a,b) a>b?a:b
#define lson l,m,rt<<1
#define rson m+1,r,rt<<1|1
#define IOS ios_base::sync_with_stdio(false),cin.tie(0),cout.tie(0)
using namespace std ;
typedef long long ll;
typedef unsigned long long ull;
const ll _max = 505;
struct node{
    int to;
    struct node *next;
};
node *List[_max];
int n,m;
int ft[_max];

void topsort(){
    priority_queue<int,vector<int>,greater<int> > q;
    while(!q.empty()) q.pop();
    int cnt = 0;
    for(int i = 0 ; i < n ; i++){
        if(!ft[i]){
            q.push(i);
            cnt++;
        }   
    }
    int id = 0;
    node *temp;
    while(!q.empty()){
        id = q.top();
        q.pop();
        temp = List[id];
        while(temp!=NULL){
            id = temp->to;
            if(--ft[id]==0){
                q.push(id);
                cnt++;
            }
            temp = temp->next;
        }
    }
    if(cnt == n) printf("YES\n");
    else printf("NO\n");
    return ;
}
int main(){
    while(~scanf("%d%d",&n,&m)){
        if(!n&&!m) break;
        memset(List,0,sizeof(List));
        memset(ft,0,sizeof(ft));
        int u,v;
        node *temp;
        for(int i = 1 ; i <= m ; i++){
            scanf("%d%d",&u,&v); 
            ft[v]++;
            temp = new node;
            temp->to = v;
            temp->next = NULL;
            if(List[u]==NULL)
                List[u]=temp;
            else{
                temp->next=List[u];
                List[u]=temp;
            }
        }
        topsort();
        for(int i = 0 ; i < n ; i++){
            temp = List[i];
            while(temp!=NULL){
                List[i] = temp->next;
                delete temp;
                temp = List[i];
            }
        }
     }
    return 0;
}

这里换了领接表31ms就行了。

### 冒泡排序算法中的交换次数计算 对于给定的一组数据,在HDOJ平台上的冒泡排序算法通过比较相邻元素来决定是否需要交换它们的位置。如果前面的元素大于后面的元素,则两者会互换位置,这一过程称为一次交换操作[^2]。 当涉及到统计具体的交换次数时,可以通过设置一个计数器`count`来进行记录。每当发生一次有效的交换(即两个逆序元素被调整顺序),就增加该计数器的值。最终输出这个计数值即可得到整个数组完成升序排列过程中发生的总交换次数。 具体实现方式如下所示: ```cpp #include<iostream> using namespace std; int main(){ int n; while(cin>>n){ int a[n], count=0; for(int i=0;i<n;i++) cin>>a[i]; // 开始冒泡排序并统计交换次数 for(int i=n-1;i>=0;i--){ bool flag=false; // 添加标志位用于优化 for(int j=0;j<i;j++){ if(a[j]>a[j+1]){ count++; swap(a[j],a[j+1]); flag=true; } } if(!flag) break; // 如果某一轮没有发生任何交换则提前结束循环 } cout<<count<<endl; } } ``` 上述代码不仅实现了基本功能还加入了额外的优化措施——一旦发现某一趟扫描中没有任何元素进行了交换就可以立即终止后续不必要的迭代,因为此时可以断定序列已经完全有序。 #### 应用场景 这种带有交换次数统计特性的冒泡排序通常适用于以下情况: - **教学目的**:帮助学生更好地理解和掌握基础排序原理及其内部运作机制。 - **性能测试**:评估不同初始状态下各种排序算法之间的效率差异,特别是关注实际运行期间所涉及的数据移动开销。 - **特定竞赛题型**:某些在线评测系统可能会设计专门针对此类特性的问题作为考察点之一,比如要求求解最小化或最大化某种条件下的交换总数等问题。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值