算法导论三

最新推荐文章于 2024-03-15 21:22:59 发布
最新推荐文章于 2024-03-15 21:22:59 发布
阅读量318 收藏 4
点赞数
分类专栏： 代码实践 资源分享 实践操作 文章标签： 算法 算法导论
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45289233/article/details/118274750
版权

背包问题

// 1.knapsack 背包问题

#include<iostream>
#include<algorithm>
#include<vector>
#include<math.h>
using namespace std;
const int volume = 100;// 背包容量
const int N = 5;//物品数量
struct OBJECTS{
    int value;
    int weight;
    float rate;
};
OBJECTS objects[N];
void swap(OBJECTS &a,OBJECTS &b)
{
    OBJECTS X;
    X = a;
    a =b;
    b =X;
}
// FOR test 
void init_1()
{
    objects[0].value=20;objects[0].weight=10;objects[0].rate=2;
    objects[1].value=30;objects[1].weight=20;objects[1].rate=1.5;
    objects[2].value=65;objects[2].weight=30;objects[2].rate=2.1;
    objects[3].value=40;objects[3].weight=40;objects[3].rate=1;
    objects[4].value=60;objects[4].weight=50;objects[4].rate=1.2;
}
//正常初始化
/* void init()
{
    float value,weight,r;
    for(int i=0;i<N;i++)
    {
        cin>>value>>weight;
        r=value/weight;
        // cin>>objects[i].value>>objects[i].weight;
        objects[i].value = value;
        objects[i].weight = weight;
        objects[i].rate = r;
    }
} */

//quicksort
//random qk_sort// n l o g n避免了最坏情况
int partition(int p,int r)
{
    float x=objects[r].rate;
    int i=p-1;
    for(int j=p;j<r;j++)
    {
        if(objects[j].rate<=x)
        {
            i+=1;
            OBJECTS X;
            X = objects[i];
            objects[i] = objects[j];
            objects[j] = X;
            //swap(a[i],a[j]);
        }
    }
    OBJECTS Y;
    Y = objects[i+1];
    objects[i+1] = objects[r];
    objects[r] = Y;
    //swap(a[i+1],a[r]);
    return i+1;
}
int random_partition(int p,int r)
{
    int i=p+rand()%(r-p+1);
    OBJECTS X;
    X = objects[i];
    objects[i] = objects[r];
    objects[r] = X;
    //swap(a[i],a[r]);
    int n;
    n=partition(p,r);
    return n;
}
void random_qk_sort(int p,int r)
{
    int q;
    if(p<r)
    {
        q=random_partition(p,r);
        random_qk_sort(p,q-1);
        random_qk_sort(q+1,r);
    }
}
//print objects struct array
void print()
{
    for(int i=0;i<N;i++)
    {
        cout<<objects[i].rate<<" ";
    }
    cout<<endl;
}
// fractional knapsack
void frac_knapsack()
{
    //quicksort nlg(n)
    random_qk_sort(0,N-1);
    float sum=0;
    float count=0;
    //贪心算法 已权值最大的优先
    for(int i=N-1;i>=0;i--)
    {
        if(sum<volume)
        {
            if(objects[i].weight<=(volume-sum))
            {
                sum+=objects[i].weight;
                count+=objects[i].value;
                cout<<i<<" "<<objects[i].value<<" "<<objects[i].weight<<endl;
            }
            else
            {   
                count+=(volume-sum)*objects[i].rate;
                //sum+=(volume-sum);
                cout<<i<<" "<<(volume-sum)*objects[i].rate<<" "<<(volume-sum)<<endl;
                sum=volume;
            }
        }
        else break;
    }
    cout<<count<<endl;
}
//0-1 knapsack 最大值155 ---1 1 1 1 0
int zero_one_knapsack()
{
    int vec[N+1][volume+1];
    for(int i=0;i<=N;i++)
    {
        vec[i][0] = 0;
    }
    for(int j = 0;j<=volume;j++)
    {
        vec[0][j]=0;
    }
    for(int i=1;i<=N;i++)
    {
        for(int j=1;j<=volume;j++)
        {
            if(j<objects[i-1].weight)
            {
                vec[i][j]=vec[i-1][j];
            }
            else{
                vec[i][j]=max(vec[i-1][j],vec[i-1][j-objects[i-1].weight]+objects[i-1].value);
            }
        }
    }
    int x[N+1];
    int j=volume;
    for(int i=N;i>0;i--)
    {
        if(vec[i][j]>vec[i-1][j])
        {
            x[i]=1;
            j=j- objects[i-1].weight;
        }
        else
        {
            x[i]=0;
        }
    }
    for(int i=1;i<=N;i++)
    {
        cout<<x[i]<<" ";
    }
    cout<<endl;
    return vec[N][volume]; 
}
int main()
{
    init_1();
    print();
    random_qk_sort(0,N-1);
    print();
    //分数背包 结果为163 时间复杂度nlg(n)
    frac_knapsack();
    //0-1 背包 最大值155 ---1 1 1 1 0
    // cout<<zero_one_knapsack()<<endl;
    return 0;
}

调度问题

//第2题 一个简单的调度问题 贪心算法
#include<iostream>
#include<vector>
#include<algorithm>
using namespace std;
int main()
{
    vector<int> jobs;
    int N;
    cout<<"please input the number of jobs:"<<endl;
    cin>>N;
    cout<<"please input time of jobs: "<<endl;
    for(int i,j=0;j<N;j++)
    {
        cin>>i;
        jobs.push_back(i);
    }
    sort(jobs.begin(),jobs.end());
    int consume=0;
    int sum=0;
    int n=jobs.size();
    for(int i=0;i<n;i++)
    {
        consume+=jobs[i];
        sum+=consume;
    }
    float average;
    average=float(sum)/float(n);
    cout<<average<<endl;
    return 0;
}
// 3 11 21 36 17.75

单源节点

//第三题 single-source 最短路径
#include<iostream>
#include<algorithm>
#include<vector>
using namespace std;
const int n=5;//the number of vertex
// const int E = 8;//the number of edge
const int s = 0;//source
int matrix[n][n];
struct VEX{
    int d;
    int pi;
};
VEX vex[n]; 
//初始化邻接矩阵,from to edge
void init()
{
    for(int i=0;i<n;i++)
    {
        for(int j=0;j<n;j++)
        {
            matrix[i][j]=INT_MAX;
        }
    }
    for(int i=0;i<n;i++)
    {
        matrix[i][i]=0;
    }
    matrix[0][1]=-1;matrix[0][2]=3;
    matrix[1][2]=3;matrix[1][3]=2;matrix[1][4]=2;
    matrix[3][1]=1;matrix[3][2]=5;
    matrix[4][3]=-3;
}
void print()
{
    for(int i=0;i<n;i++)
    {
        for(int j=0;j<n;j++)
        {
            cout<<matrix[i][j]<<" ";
        }
        cout<<endl;
    }
}
//对最短路径估计与前驱结点进行初始化
void init_single_source(int s)
{
    for(int i=0;i<n;i++)
    {
        vex[i].d=INT_MAX;
    }
    vex[s].d=0;
}
//松弛操作
void relax(int u,int v,int w )
{
    if(vex[v].d>(vex[u].d+w))
    {
        vex[v].d=vex[u].d+w;
        vex[v].pi=u;
    }
}
bool Bellman_ford(int s)
{
    init_single_source(s);
    for(int i=1;i<n;i++)
    {
        for(int j=0;j<n;j++)
        {
            for(int k=0;k<n;k++)
            {
                if(matrix[j][k]!=INT_MAX)
                {
                    relax(j,k,matrix[j][k]);
                }
            }
        }
    }
    for(int i=0;i<n;i++)
    {
        for(int j=0;j<n;j++)
        {
            if(matrix[i][j]!=INT_MAX)
            {
                if(vex[j].d>(vex[i].d+matrix[i][j])) return false;
            }
        }
    }
    return true;
}
void out(int target)
{
    if(target>0)
    {
        target=vex[target].pi;//前驱
        out(target);
        cout<<target<<"->";
    }
}
int main()
{
    init();//初始化邻接矩阵
    // print();
    int target;
    cout<<"please input the vertex you wana to get:"<<endl;
    cin>>target;
    /* cout<<"input the source:"<<endl;
    cin>>s; */
    if(Bellman_ford(s))
    {
        cout<<"最短路径："<<endl;
        out(target);//输出最短路径经过的结点
        cout<<target<<endl;
        cout<<"最短路径权重值之和"<<endl;
        cout<<vex[target].d<<endl;//输出最短路径权重值之和
    }
    return 0;
}

多源点路径

//第四题 多元点路径
#include<iostream>
#include<algorithm>
#include<math.h>
#include<vector>
using namespace std;
const int n=5;//the number of vertex
int matrix[n][n];
int P[n][n];
int D[n][n];
// #define INT_MAX 9999
//初始化邻接矩阵,from to edge
void init()
{
    for(int i=0;i<n;i++)
    {
        for(int j=0;j<n;j++)
        {
            matrix[i][j]=INT_MAX;
        }
    }
    for(int i=0;i<n;i++)
    {
        matrix[i][i]=0;
    }
    matrix[0][1]=-1;matrix[0][2]=3;
    matrix[1][2]=3;matrix[1][3]=2;matrix[1][4]=2;
    matrix[3][1]=1;matrix[3][2]=5;
    matrix[4][3]=-3;
}
void print(int m[n][n])
{
    for(int i=0;i<n;i++)
    {
        for(int j=0;j<n;j++)
        {
            cout<<m[i][j]<<" ";
        }
        cout<<endl;
    }
}


void floyd_warshall()
{
    //int D[n][n];//路径代价矩阵
    //int P[n][n];//前驱矩阵
    //初始化D
    for(int i=0;i<n;i++)
    {
        for(int j=0;j<n;j++)
        {
            D[i][j]=matrix[i][j];
        }
    }
    /* print(matrix);
    cout<<endl;
    print(D);
    cout<<endl; */
    //初始化P
    for(int i=0;i<n;i++)
    {
        for(int j=0;j<n;j++)
        {
            if(matrix[i][j]!=0&&matrix[i][j]!=INT_MAX)
            {
                P[i][j]=i;
            }
            else{
                P[i][j]=INT_MAX;
            }
        }
    }
    // print(P);
    for(int k=1;k<=n;k++)
    {
        for(int i=1;i<=n;i++)
        {
            for(int j=1;j<=n;j++)
            {
                if(D[i-1][j-1]>(D[i-1][k-1]+D[k-1][j-1])&&D[i-1][k-1]!=INT_MAX&&D[k-1][j-1]!=INT_MAX) 
                {
                    P[i-1][j-1]=P[k-1][j-1];//前驱
                    D[i-1][j-1]=D[i-1][k-1]+D[k-1][j-1];
                }
                //D[i-1][j-1]=min(D[i-1][j-1],D[i-1][k-1]+D[k-1][j-1]);
            }
        }
    }
    print(D);
}
void out(int s,int e)
{
    /* cout<<P[s][e];
    cout<<endl; */
    if(P[s][e]!=s)
    {
        out(s,P[s][e]);
        cout<<P[s][e]<<"->";
    }

}
int main()
{
    int start,end;
    init();
    //int D[n][n];
    floyd_warshall();
    cout<<"please input start and end pots:"<<endl;
    cin>>start>>end;
    if(D[start][end]!=INT_MAX||D[start][end]!=0)
    {
        cout<<"最短路径代价：";
        cout<<D[start][end]<<endl;
        cout<<"最短路径：";
        cout<<start<<"->";
        out(start,end);
        cout<<end<<endl;
    }
    else{
        cout<<"不存在最短路径"<<endl;
    }
    return 0;
}
会编程的道君
关注
  • 0
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
算法导论 思考题 13.3-4(Treap树)
苦海无涯闯进来
05-15 464
1
算法导论 练习题 13.3-4
苦海无涯闯进来
05-13 569
1
算法导论第十三章习题解答
12-28
能用代码表示的都用代码表示，不能表示的写出思路，思路都没写的就是我也做不出来
算法导论 练习题 13.4-4
苦海无涯闯进来
05-14 410
1
算法导论13章习题答案CLRS
01-14
算法导论第三版13章的习题答案，配图，很详细
算法导论答案译文导航
最新发布
TXLTF的博客
03-15 2687
算法导论第一章练习参考答案(1) - 1.1-1.2https://blog.csdn.net/TXLTF/article/details/131675589算法导论第二章练习参考答案(2) - 2.1-2.3https://blog.csdn.net/TXLTF/article/details/131677038算法导论第二章思考题参考答案(3)https://blog.csdn.net/TXLTF/article/details/131699788算法导论第三章练习参考答案(4) - 3.1-3.2ht
算法导论 第三版 中文pdf
03-23
算法导论 第三版 中文pdf
算法导论中文第三版习题答案
04-07
"算法导论（第三版）基本完整中文版答案"这个压缩包文件包含了书中的习题答案，涵盖了各个章节。文件名直接反映了其内容，用户可以通过解压并查阅这些文件，找到对应习题的解答。这不仅节省了寻找答案的时间，也避免...
算法导论3英文kindle
01-08
1.1 Algorithms Informally, an algorithm is any well-defined computational procedure that takes some value, or set of values, as input and produces some value, or set of values, as ...
算法导论.rar
05-07
《算法导论》第三版还引入了最新的研究成果，如近似算法、线性规划和动态规划的更深入探讨，以及新加入的计算几何和网络流等内容，使得这本教材更加全面和实用。无论是初学者还是专业人士，都能从中受益匪浅，提升...
算法导论第三版答案（完整版）
05-16
标题中的“算法导论第三版答案（完整版）”意味着这份资源提供了书中的所有习题解答，这对于读者自我检验学习成果、深入理解概念和技巧非常有帮助。 描述中提到，网上的答案通常不完整，而这份资源是完整版，每章的...
算法导论13.4删除 练习总结
chan15的博客
10-18 3331
13.4-1 在执行 RB-DELETE-FIXUP 之后，证明：树根一定是黑色的。 ANSWER： case 1：要进入循环，则 x.color = BLACK，且 x ≠ T.nil，所以不可能从case 1退出循环，所以必定会进入case 2,3,4。 case 2：w = x.p.right，则 w 不可能是T.root；如果从case 2退出循环，则 x = T.root，则23行
算法导论 练习题 13.4-1
苦海无涯闯进来
05-14 336
1
《算法导论》笔记 第13章 13.4 删除
Azarath Metrion Zinthos
04-24 1554
【笔记】 NODE* rbDelete(NODE *z) { NODE *y, *x; if (z->l == nil || z->r == nil) { y = z; } else { y = treeSuccessor(z); } if (y->l != nil) { x = y->l; } el
算法导论13-4：Treap
彦祖老师
01-15 2458
花了一晚上终于解决了《算法导论》13-4 中的思考题 Treap，之前学习的时候就发现这块的内容网上都找不到什么参考资料，面对a---j这几个思考题一筹莫展，今晚静下心来好好研究了下，发现也不是那么难啃。搞算法，就是要沉得住气。
算法导论13.3插入 练习总结
chan15的博客
10-15 3515
13.3-1 在 RB-INSERT 的第 16 行，将心插入的结点 z 着为红色。注意到，如果将 z 着为黑色，则红黑树的性质 4 就不会被破坏。那么为什么不选择将 z 着为黑色呢？ ANSWER：为了保持性质5，令红黑树的黑高不变。 13.3-2 将关键字 41、38、31、12、19、8 连续地插入一棵初始化为空的红黑树之后，试画出该结果树。 ANSWER：
《算法导论》第三版第13章 红黑树 练习&思考题 个人答案
张劲声的博客
03-11 5255
13.1 红黑树的性质 13.1-1 解： 完全二叉搜索树： 黑高为2的红黑树： 黑高为3的红黑树： 黑高为4的红黑树： 13.1-2 解：如果标红，不满足性质4，因为35是36的父结点，也是红色；如果标黑，不满足性质5，该条路径黑高超过其他路径。 13.1-3 解：可以验证所得到的树仍然满足5个条件，所以是红黑树。 13.1-4 解： （1）如果“吸收”前两个子结点都已经是黑色了，度为2...
Ubuntu20.04下添加自定义系统调用
qq_45289233的博客
06-08 3673
Ubuntu20.04下添加自定义系统调用 实验环境 1.VM15.15Pro 2.Ubuntu20.04 3.内核版本Linux-5.6.15 操作步骤 添加系统调用内核 下载Linux-5.6.15内核版本，将压缩包复制到虚拟机的桌面，并移动到/usr/src文件夹中并解压。 命令：sudo mv linux-5.6.15.tar.xz /usr/src sudo tar -xvf linux-5.6.15.tar.xz 下载编译所需的软件依赖包 sudo apt-get update sudo ap
C++面向对象程序设计-桌面计算器实现
qq_45289233的博客
03-26 1539
C++面向对象程序设计-桌面计算器实现 源代码 /** ***************** * program: * END //END is end-of-input * expr_list END * expr_list: * expression PRINT // PRINT is semicolon * expre...
算法导论 第3版pdf
08-25
《算法导论 第3版》是一本经典的计算机科学教材，由Thomas H.Cormen、Charles E.Leiserson、Ronald L.Rivest和Clifford Stein合著，主要介绍了算法设计与分析的基本原理和技巧。 这本教材分为六个部分，共29章。第...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值