计算机算法设计与分析课程设计常规题目的(C及C++)代码集

合并排序1：
#include<iostream>
using namespace std;
const int N=100;
class list
{
public:
int array[N];
void input(int a);
void merge(int arrayc[],int arrayd[],int l,int m,int r); void mergepass(int array*[],int arrayy[],int s);
void mergesort(int array1[]);
void diaplay(int a);
};
void list::input(int a)
{
cout<<"Please input shorted array:"<<endl;
for(int i=0;i<a;i++)
cin>>array[i];
}
void list::merge(int arrayc[],int arrayd[],int l,int m,int r) {
int i=l;
int j=m+1;
int k=l;
while((i<=m)&&(j<=r))
if(arrayc[i]<=arrayc[j])
arrayd[k++]=arrayc[i++];
else arrayd[k++]=arrayc[j++];
if(i>m)
for(int q=j;q<=r;q++)
arrayd[k++]=arrayc[q];
else
for(int q=i;q<=m;q++)
arrayd[k++]=arrayc[q];
}
void list::mergepass(int array*[],int arrayy[],int s)
{
int i=0;
while(i<=N-2*s)
{
merge(array*,arrayy,i,i+s-1,i+2*s-1);
i=i+2*s;
}
if((i+s)<N)
merge(array*,arrayy,i,i+s-1,N-1);
else
for(int j=i;j<N;j++)
arrayy[j]=array*[j];
}
void list::mergesort(int array1[])
{
int array2[N];
int s=1;
while(s<N)
{
mergepass(array1,array2,s);
s+=s;
mergepass(array2,array1,s);
s+=s;
}
}
void list::diaplay(int a)
{
for(int i=N-a;i<N;i++)
cout<<array[i];
}
void main()
{
list f;
int a;
cout<<"请输入要合并排序的数组大小：(数组最大上限 100)"<<endl; cin>>a;
f.input(a);
f.mergesort (f.array);
f.diaplay (a);
}
合并排序：2
#include <iostream>
usingnamespace std;
void MERGES(int *A,int p,int q,int r) //下标 P<=q<r
{
int n1=q-p+1; //n1:p,q之间的数的个数
int n2=r-q; //n2：q以后到r的数的个数
int *L=newint [n1+1], //动态申请两个子数组
*R=newint [n2+1];
int i,j,k;
for (i=0;i<n1;i++)
{
L[i]=A[p+i-1];
}
for (j=0;j<n2;j++)
{
R[j]=A[q+j];
}
L[n1]=10000; //设置哨兵
R[n2]=10000;
i=0;
j=0;
for (k=p-1;k<r;k++)
{
if (L[i]<=R[j])
{
A[k]=L[i];
i=i+1;
}
else
{
A[k]=R[j];
j=j+1;
}
}
}
void MERGESORT(int *A,int p,int r) {
if (p<r)
{
int q=(p+r)/2;
MERGESORT(A,p,q);
MERGESORT(A,q+1,r);
MERGES(A,p,q,r);
}
}
void main()
{
int *,z,p,r;
cout<<"请输入数组长度"<<endl; cin>>*;
int *A= newint[*];
cout<<"请输入数组的元素"<<endl;
for(int y=0;y<*;y++)
{
cin>>z;
A[y]=z;
}
cout<<"请输入上下限p，r"<<endl;
cin>>p>>r;
MERGESORT(A,p,r);
cout<<"合并排序后为："<<endl;
for (int m=p;m<=r;m++)
{
cout<<A[m];
}
delete []A;
}
合并排序3：
#include <iomanip.h>
#include <iostream.h> //这个函数将b[0]至b[right-left+1]拷贝到a[left]至a[right]
template <class T>
void Copy(T a[],T b[],int left,int right)
{
int size=right-left+1;
for(int i=0;i<size;i++)
{
a[left++]=b[i];
}
} //这个函数合并有序数组a[left:i],a[i+1:right]到b,得到新的有序数组b template <class T>
void Merge(T a[],T b[],int left,int i,int right)
{
int a1cout=left,//指向第一个数组开头
a1end=i,//指向第一个数组结尾
a2cout=i+1,//指向第二个数组开头
a2end=right,//指向第二个数组结尾
bcout=0;//指向b中的元素
for(int j=0;j<right-left+1;j++)//执行right-left+1次循环
{
if(a1cout>a1end)
{
b[bcout++]=a[a2cout++];
continue;
}//如果第一个数组完毕，拷贝第二个数组的元素到b
if(a2cout>a2end)
{
b[bcout++]=a[a1cout++];
continue;
}//如果第二个数组完毕，拷贝第一个数组的元素到b
if(a[a1cout]<a[a2cout])
{
b[bcout++]=a[a1cout++];
continue;
}//如果两个数组都没完毕，比拟元素大小，把较小的放入b
else
{
b[bcout++]=a[a2cout++];
continue;
}
}
} //对数组a[left:right]进展合并排序
template <class T>
void MergeSort(T a[],int left,int right)
{
T *b=new int[right-left+1];
if(left<right)
{
int i=(left+right)/2;//取中点
MergeSort(a,left,i);//左半边进展合并排序
MergeSort(a,i+1,right);//右半边进展合并排序
Merge(a,b,left,i,right);//左右合并到b中
Copy(a,b,left,right);//从b拷贝回来
}
} //from hi.baidu./zhangam*qun
int main()
{
int n;
cout<<"how many numbers to sort:";
cin>>n;
int *a=new int[n];
cout<<"input "<<n<<" numbers:";
for(int i=0;i<n;i++)
{
cin>>a[i];
}
MergeSort( a, 0, n-1);
for(int j=0;j<n;j++)
{
cout<<setw(5)<<a[j];
}
return 1;
}
合并排序4：
#include <iostream>
using namespace std;
void Merge(int a[],int b[],int l,int m,int r) {
int i=l,j=m+1,k=l;
while ((i<=m)&&(j<=r))
if (a[i]<=a[j])b[k++]=a[i++];
else b[k++]=a[j++];
if (i>m)
for(int q=j;q<=r;q++)
b[k++]=a[q];
else
for(int q=i;q<=m;q++)
b[k++]=a[q];
}
void Copy(int a[],int b[],int s,int n)
{
for(int i=s;i<=n;i++)
a[i]=b[i];
}
void MergeSort(int a[],int left,int right) {
int i;
if(left<right)
{
i=(left+right)/2;
int b[100];
MergeSort(a,left,i);
MergeSort(a,i+1,right);
Merge(a,b,left,i,right);
Copy(a,b,left,right);
}
}
int main()
{
int a[100];
int n,i;
cout<<"输入元素个数n:";
cin>>n;
cout<<"输入一维数组a["<<n<<"]:";
for( i=0;i<n;i++)
cin>>a[i];
MergeSort(a,0,n-1);
cout<<"输出排序为:";
for ( i=0;i<n;i++)
cout<<a[i]<<' ';
cout<<endl;
return 0;
}
矩阵相乘1:
#include <iostream>
#include <stdio.h>
using namespace std;
int main()
{
int i, j, k;
cout<<"输入二维数组a的行数和二维数组c的行数*:"; int *;
cin>>*;
cout<<"输入二维数组a的列数和二维数组b的行数y:";
int y;
cin>>y;
cout<<"输入二维数组b的列数和二维数组c的行数z:"; int z;
cin>>z;
int **a, **b, **c;
a=new int*[*];
for(i=0;i<*;i++)
{
a[i]=new int[y];
}
cout<<"输入二维数组a:"<<endl;
for(i=0;i<*;i++)
{
for(j=0;j<y;j++)
{
cin>>a[i][j];
}
}
b=new int*[y];
for(i=0;i<y;i++)
{
b[i]=new int [z];
}
cout<<"输入二维数组b:"<<endl;
for(i=0;i<y;i++)
{
for(j=0;j<z;j++)
{
cin>>b[i][j];
}
}
c=new int*[*];
for(i=0;i<*;i++)
{
c[i]=new int [z];
}
cout<<"输入二维数组c:"<<endl;
for(i=0;i<*;i++)
{
for(j=0;j<z;j++)
{
c[i][j]=0;
}
}
for(i=0;i<*;i++)
{
for(j=0;j<z;j++)
{
for(k=0;k<y;k++)
{
c[i][j]+=a[i][k]*b[k][j];
}
}
}
for(i=0;i<*;i++)
{
for(j=0;j<z;j++)
{
cout<<c[i][j]<<' ';
}
cout<<endl;
}
for(i=0;i<*;i++)
{
delete [] a[i];
}
delete [] a;
for(i=0;i<*;i++)
{
delete [] c[i];
}
delete [] c;
for(i=0;i<y;i++)
{
delete [] b[i];
}
delete [] b;
return 0;
}
矩阵相乘2：
#include<iostream>
using namespace std;
#define M 2
#define N 3
#define P 4
int main()
{
int a[M][N]={{1,2,3},{4,5,6}};
int b[N][P]={{7,8,9,1},{2,3,4,5},{6,7,8,9}};
int c[M][P];
int i,j,k;
for(i=0;i<M;i++)
for(j=0;j<P;j++)
c[i][j]=0;
for(i=0;i<M;i++)
for(j=0;j<P;j++)
for(k=0;k<N;k++)
c[i][j]+=a[i][k]*b[k][j];
cout<<"矩阵相乘结果是："<<endl;
for(i=0;i<M;i++){for(j=0;j<P;j++)
cout<<c[i][j]<<" ";
cout<<endl;
}//system("pause");
return 0;
}
矩阵相乘3：
#include <iostream>
#include <iomanip>
using namespace std;
int main()
{
const int m=3;
const int n=3;
int a[m][n],i,j; //初始化数组 a,b
for(i=0;i<m;i++) //对数组 a 赋值并显示
{
for( j=0;j<n;j++)
{
cout<<"a["<<i<<"]"<<"["<<j<<"]=";
cin>>a[i][j];
}
}
for( i=0;i<m;i++)
{
for( j=0;j<n;j++)
cout<<setw(4)<<a[i][j];
cout<<endl;
}
const int k=3;
const int h=2;
int b[k][h],*,y;
for( *=0;*<k;*++)
{
for( y=0;y<h;y++)
{
cout<<"b["<<*<<"]"<<"["<<y<<"]=";
cin>>b[*][y];
}
}
for( *=0;*<k;*++)
{
for( y=0;y<h;y++)
cout<<setw(4)<<b[*][y];
cout<<endl;
}
int c[m][h]; //乘赋值给数组 c
for(int r=0;r<m;r++)
{
for(int t=0;t<h;t++) //数组 a 与 b 相//对数组 b 赋值并显示
{
c[r][t]=0;
for(int s=0;s<k;s++)
{
c[r][t]+=a[r][s]*b[s][t];
}
}
}
cout<<"c["<<m<<"]"<<"["<<h<<"]"<<endl;
for(int z=0;z<m;z++)
{
for(int w=0;w<h;w++)
cout<<setw(4)<<c[z][w];
cout<<endl;
}
return 0; //显示数组 c
}
矩阵相乘4：
#include<iostream>
using namespace std;
void chain(int*p,int n,int m[][7],int s[][7])//p维数数组，m最优乘次数组，s记录划分方案
{
int j;
for(int i=1;i<=n;i++)
m[i][i]=0;
for(int r=2;r<=n;r++)
{
for(i=1;i<=n-r+1;i++)
{
j=i+r-1;
m[i][j]=m[i+1][j]+p[i-1]*p[i]*p[j];
s[i][j]=i;
for(int k=i+1;k<j;k++)
{
int t=m[i][k]+m[k+1][j]+p[i-1]*p[k]*p[j];
if(t<m[i][j])
{
m[i][j]=t;
s[i][j]=k;
}
}
}
}
for(i=1;i<=n;i++)//我把它翻过来输出。

{
for(j=n;j>=i;j--)
{
cout<<m[i][j]<<'';
}
cout<<endl;
}
}
void Traceback(int i,int j,int s[][7])//输出相乘方案{
if(i==j)
return;
Traceback(i,s[i][j],s);
Traceback(s[i][j]+1,j,s);
cout<<"Multiply A"<<i<<","<<s[i][j];
cout<<"and B"<<(s[i][j]+1)<<","<<j<<endl;
return;
}
int main()
{
int p[7],m[7][7],s[7][7],n;
while(n!=EOF)
{
for(int i=0;i<=n;i++)
{
cin>>p[i]>>endl;
}
chain(p,n,m,s);
Traceback(1,6,s);
}
return 0;
}
Haffman编码1：
#include<iostream>
#include<string>
using namespace std;
typedef struct
{
int weight;
int flag;
int parent;
int lchild;
int rchild;
}
hnodetype;
typedef struct
{
int bit[10];
int start;
char leaf;
}
hcodetype;
void huf(char cha[],int m[],int n)
{
int i,j,m1,m2,*1,*2,c,p;
hnodetype *huffnode=new hnodetype[2*n-1];
hcodetype *huffcode=new hcodetype[n],cd;
for(i=0;i<2*n-1;i++)
{
huffnode[i].weight=0;
huffnode[i].parent=0;
huffnode[i].flag=0;
huffnode[i].lchild=-1;
huffnode[i].rchild=-1;
}
for(i=0;i<n;i++)
{
huffnode[i].weight=m[i];
huffcode[i].leaf=cha[i];
}
for(i=0;i<n-1;i++)
{
m1=m2=10000000;
*1=*2=0;
for(j=0;j<n+i;j++)
{
if (huffnode[j].weight<=m1&&huffnode[j].flag==0)
{
m2=m1;
*2=*1;
m1=huffnode[j].weight;
*1=j;
}
else if(huffnode[j].weight<=m2&&huffnode[j].flag==0)
{
m2=huffnode[j].weight;
*2=j;
}
}
huffnode[*1].parent=n+i;
huffnode[*2].parent=n+i;
huffnode[*1].flag=1;
huffnode[*2].flag=1;
huffnode[n+i].weight=huffnode[*1].weight+huffnode[*2].weight;
huffnode[n+i].lchild=*1;
huffnode[n+i].rchild=*2;
}
for(i=0;i<n;i++)
{
cd.start=n-1;
c=i;
p=huffnode[c].parent;
while(p!=0)
{
if(huffnode[p].lchild==c)
cd.bit[cd.start]=0;
else
cd.bit[cd.start]=1;
cd.start--;
c=p;
p=huffnode[c].parent;
}
cout<<huffcode[i].leaf<<":";
for(j=cd.start+1;j<n;j++)
{
huffcode[i].bit[j]=cd.bit[j];
cout<<cd.bit[j];
}
cout<<endl;
huffcode[i].start=cd.start;
}
delete[] huffcode;
delete[] huffnode;
}
void main()
{
string str;
int i=0,j,n,m[100],h,k=0;
char cha[100];
cout<<"请输入一个字符串"<<endl;
cin>>str;
n=str.length();
cout<<"字符串总共有字符"<<n<<"个"<<endl;
for(i=0;i<n;i++)
{
j=0;
h=0;
while(str[i]!=str[j])
j++;
if(j==i)
{
cha[k]=str[i];
cout<<"字符"<<cha[k]<<"出现";
}
else continue;
for(j=i;j<n;j++)
{
if(str[i]==str[j])h++;
}
cout<<h<<"次"<<endl;
m[k]=h;
k++;
}
cout<<"每个字符的哈夫曼编码是："<<endl;
huf(cha,m,k);
cin.get();
cin.get();
}
Haffman编码2：
#include <iostream>
using namespace std;
//********************************//构造哈夫曼树//********************************/*哈夫曼树顺序表的定义*/
typedef struct
{
int weight;
int parent,lchild,rchild;
}
HTNode;
typedef HTNode * HuffmanTree;/*初始化一个哈夫曼树*/
void InitHuffmanTree(HuffmanTree &HT,int m)
{
int i;
HT=new HTNode[m];
for(i=0;i<m;i++)
{
HT[i].weight=0;
HT[i].parent=-1;
HT[i].lchild=-1;
HT[i].rchild=-1;
}
}
//****************************************//从n个结点中选取最小的两个结点
//****************************************
void SelectMin(HuffmanTree &HT,int n,int &min1,int &min2)
{
typedef struct
{
int NewWeight;//存储权
int p;//存储该结点所在的位置
}
TempNode,*TempTree;
TempTree TT=new TempNode[n];
int i,j;
j=0;
for(i=0;i<n;i++)
{
if(HT[i].parent==-1 && HT[i].weight!=0)
{
TT[j].NewWeight=HT[i].weight;
TT[j].p=i;
j++;
}
}//将HT中没有双亲的结点存储到TT中
int m1,m2;
m1=m2=0;
for(i=0;i<j;i++)
{
if(TT[i].NewWeight<TT[m1].NewWeight)//此处不让取到相等，是因为结点中有一样权值的时候，m1取最前的那个。

m1=i;
}
for(i=0;i<j;i++)
{
if(m1==m2)
m2++;//当m1在第一个位置的时候，m2向后移一位
if(TT[i].NewWeight<=TT[m2].NewWeight && i!=m1)//此处取到相等，是让在结点中有一样的权值的时候，//m2取最后的那个。

m2=i;
}
min1=TT[m1].p;min2=TT[m2].p;
}/*创立哈夫曼树*/
void CreateHaffmanTree(HuffmanTree &HT,int n)
{
int i;
int m;
int min1,min2;
if(n<=1)
cout<<"Parameter Error!";
m=2*n-1;//哈夫曼树中结点的个数
InitHuffmanTree(HT,m);
for(i=0;i<n;i++)
{
cin>>HT[i].weight;
}
for(i=n;i<m;i++)
{
SelectMin(HT,i,min1,min2);
HT[min1].parent=i;
HT[min2].parent=i;
HT[i].lchild=min1;
HT[i].rchild=min2;
HT[i].weight=HT[min1].weight+HT[min2].weight;
cout<<min1<<" "<<min2<<endl;
}
}
//***********************************//构造哈夫曼编码//***********************************/*哈夫曼编码的定义*/
typedef struct
{
char ch;
char bits[10];
}
CodeNode;
typedef CodeNode * HuffmanCode;/*哈夫曼编码的构造*/
void CreateHuffmanCode(HuffmanTree &HT,HuffmanCode &HC,int n)
{
int i;
int start;
int c;
int p;
char *cd;
char q;
HC=new CodeNode[n];
cd=new char[n];
cd[n-1]='/0';
for(i=0;i<n;i++)
{
cin>>q;
HC[i].ch=q;
start=n-1;
while((p=HT[c].parent)>=0)
{
--start;
cd[start]=(HT[p].lchild==c)“'0':'1';c=p;
}
strcpy(HC[i].bits,&cd[start]);
}
delete cd;
}/*哈夫曼编码的输出*/
void OutputHuffmanCode(HuffmanCode &HC,int n)
{
int i;
for(i=0;i<n;i++)
{
cout<<HC[i].ch<<" "<<HC[i].bits<<endl;
}
}
void main()
{
int i;
cout<<"输入字符个数：";
cin>>i;
HuffmanTree HT;
HuffmanCode HC;
CreateHaffmanTree(HT,i);
CreateHuffmanCode(HT,HC,i);
OutputHuffmanCode(HC,i);
}
图形着色1：
#include <cstdlib>
#include <iostream>//回溯法
using namespace std;//judge the coloration isValid or not. bool isValid(bool b[5][5], int k, int *[])
{
for(int i=0; i<k; ++i)
if(!b[k][i])
continue;
else if(b[k][i] && *[k]== *[i])
return false;
return true;
}//by : 乔木
int main(int argc, char *argv[])
{
int m = 3;//第i个顶点的着色( 解向量 )
int *[5];
bool b[5][5]={ true,true,true,false,false,true, true,true,true,true,true, true,true,false,true,false,true,false,true,true,false,true,true,true,true };
for(int i=0; i<5; i++)
*[i] = 0;
int k=0;//whiles
while(k>=0)
{
*[k] = *[k] + 1;//着色无效继续再当前层搜索有效的颜色
while(*[k]<=m && !isValid(b, k, *))
*[k] = *[k] + 1;
if(*[k]<=m)
{
if(k==n-1)
break; //successelse
//为下一个结点着色
k = k+1;
}
else
{ //返回至上一层
*[k] = 0;
k = k-1;
}
}//print
cout << "Five verte*es' coloration scheme is: " << endl;
for(int j=0; j<5; j++)
cout << *[j] << " ";
cout << endl;
system("PAUSE");
return E*IT_SUCCESS;
}
0-1背包回溯法1：
#include<iostream.h>
using namespace std;
template<class Typew,class Typep>
class Knap
{
friend Typep Knapsack(Typep*,Typew*,Typew,int);
private:
Typep Bound(int i);
void Backtrack(int i);
Typew c;
Typew *w;
Typep *p;
Typew cw;
Typep cp;
Typep bestp;
};
template<class Typew,class Typep>
Typep Knap<Typew,Typep>::Bound(int i)
{
Typew cleft=c-cw;
Typep b=cp;
while(i<=n&&w[i]<=cleft)
{
cleft-=w[i];
b+=p[i];
i++;
}
if(i<=n)b+=p[i]/w[i]*cleft;
return b;
}
template<class Typew,class Typep>
void Knap<Typew,Typep>::Backtrack(int i)
{
if(i>n)
{
bestp=cp;
return;
}
if(cw+w[i]<=c)
{
cw+=w[i];
cp+=p[i];
Backtrack(i+1);
cw-=w[i];
cp-=p[i];
}
if(Bound(i+1)>bestp)
Backtrack(i+1);
}
class Object
{
friend int Knapsack(int *,int *,int,int); public:
int operator<=(Object a)const
{
return(d>=a.d);
}
private:
int ID;
float d;
};
template<class Typew,class Typep> {
Typep W=0;
Typep P=0;
Object*Q=new Object[n];
for(int i=1;i<=n;i++)
{
Q[i-1].ID=i;
Q[i-1].d=1.0*p[i]/w[i];
P+=p[i];
W+=w[i];
}
if(W<=c)return P;
sort(Q,n);
Knap<Typew,Typep>K;
K.p=new Typep[n+1];
K.w=new Typew[n+1];
for(int i=1;i<=n;i++)
{
K.p[i]=p[Q[i-1].ID];
K.w[i]=w[Q[i-1].ID];
}
K.cp=0;
K.cw=0;
K.c=c;
K.n=n;
K.bestp=0;
K.Backtrack(1);
delete[]Q;
delete[]K.w;
delete[]K.p;
return K.bestp;
};
int main()
{
int p[]={0,4,3,5,6,3};
int w[]={0,3,5,6,2,7};
int *p1=p;
int *w1=w;
int c=10,n=5;
int best*[6];
int *=Knapsack(p1,w1,c,n);
cout<<"best="<<c<<endl;
for(int i=0;i<6,i++)
{
cout<<best*[i];
}
cout<<"Result";
return 0;
}
0-1背包动态规划法：
#include<iostream>
#include<fstream>
#include<memory.h>
using namespace std;
int ma*(int i,int j)
{
return i>j“i:j;
}
int min(int i,int j)
{
return i<j“i:j;
}
template<class Type>
void Knapsack(Type *v,int *w,int c, int n,Type **m) {
//0-1背包算法
int jMa* = min(w[n]-1,c);
for(int j=0;j<=jMa*;j++)
{
m[n][j]=0;
}
for(int t=w[n];t<=c;j++)
{
m[n][t]=v[n];
}
for(int i=n-1;i>1;i--)
{
jMa*=min(w[i]-1,c);
for(int j=0;j<=jMa*;j++)
m[i][j]=m[i+1][j];
for(int k=w[i];j<=c;j++)
m[i][k]=ma*(m[i+1][k],m[i+1][k-w[i]]+v[i]);
}
m[1][c]=m[2][c];
if(c>=w[1])
m[1][c]=ma*(m[1][c],m[2][c-w[1]]+v[1]);
}
template<class Type>
void TraceBack(Type **m,int *w,int c,int n,int* *)
{
//计算0-1背包路径
for(int i=1;i<n;i++)
{
if(m[i][c] == m[i+1][c])
*[i]=0;
else
{
*[i]=1;
c-=w[i];
}
}
*[n]=(m[n][c])“1:0;
}
void main()
{
//物品量n，承载重量c，各物体重量：w，各物体价值：v //m用来存储动态规划的子构造值
int n,c,i;
int *w,*v,**;
int **m;
ifstream input("Input.t*t",ios::in);
ofstream output("Output.t*t",ios::out);
if(!input || !output)
{
cerr<<"File open or create error!"<<endl;
e*it(0);
}
else
{
input>>n>>c;
w=new int[n+1];
v=new int[n+1];
*=new int[n+1];
m=new int*[n+1];
for(i=0;i<=n;i++)
{
m[i]=new int[c+1];
memset(m[i],0,(c+1)*sizeof(int));
}
for(i=1;i<=n;i++)
input>>w[i];
for(i=1;i<=n;i++)
input>>v[i];
input.close();
for(i=0;i<n+1;i++)
for(int j=0;j<c+1;j++)
m[i][j]=0;
Knapsack(v,w,c,n,m);
for(i=0;i<=n;i++)
{
for(int k=0;k<=c;k++)
output<<m[i][k]<<" ";
output<<endl;
}
output<<endl;
TraceBack(m,w,c,n,*);
for(i=1;i<=n;i++)
output<<*[i]<<" ";
output.close(); //回收存
for(i=0;i<=n;i++)
delete [] m[i];
delete []w;
delete []v;
delete []*;
delete []m;
}
}
0-1背包回溯法2：
#include <iostream>
using namespace std;
void input(int *number,int *weight,int *price) {
int i,n;
cout<<"包的容量: ";
cin>>weight[0];
cout<<"物品数: ";
cin>>*number;
cout<<"各物品的重量: ";
for(i=1;i<=*number;i++)
{
cin>>weight[i];
}
cout<<"各物品的价值: ";
for(i=1;i<=*number;i++)
{
cin>>price[i];
}
}
void backtrack(int t,int n,int *weight,int *price,int *ma*Price,int *flag,int *nowWeight,int *nowPrice,int **)
{
int i;
if(t>n)
{
if(*nowWeight<=weight[0]&&*nowPrice>*ma*Price)
{
//cout<<" ma*Price is "<<*ma*Price<<" nowPrice is "<<*nowPrice<<endl<<endl;
*ma*Price=*nowPrice;
flag[0]=0;
for(i=1;i<=n;i++)
{
if(*[i])
{
//cout<<"深度是: "<<t<<" i 是 "<<i<<endl<<endl;
flag[++flag[0]]=i;
}
}
}
return;
}
else
{
for(i=0;i<=1;i++)
{
*[t]=i;
*nowWeight+=weight[t]*i;
*nowPrice+=price[t]*i;
// cout<<"nowPrice is "<<*nowPrice<<" 深度是:"<<t<<" *["<<t<<"] 是 :"<<i<<endl;
backtrack(t+1,n,weight,price,ma*Price,flag,nowWeight,nowPrice,*);
*nowWeight-=weight[t]*i;
*nowPrice-=price[t]*i;
}
}
}
void output(int *ma*Price,int *flag)
{
int i;
cout<<endl;
cout<<"最大价值:";
cout<<*ma*Price<<endl;
cout<<"所选物品为:";
for(i=1;i<=flag[0];i++)
{
cout<<flag[i]<<" ";
}
cout<<endl;
}
int main()
{
int temp1=0,temp2=-1,temp3=0,temp4=0;//这一行很重要
int *number=&temp1,weight[100],price[100];
int *ma*Price=&temp2,flag[100],*nowWeight=&temp3,*nowPrice=&temp4,*[100];
input(number,weight,price);
backtrack(1,*number,weight,price,ma*Price,flag,nowWeight,nowPrice,*);
output(ma*Price,flag);
return 0;
}
最小生成树prim法1：
#include<string>
#include<iostream>
using namespace std;
struct MGraph
{
void createGraph(int n,int m);
int Prim(int u);
int mat[100][100]; // 弧的信息
int ve*num; // 顶点数
int MinVerte*(int dist[],bool visited[]);
};
int MGraph::Prim( int u)
{ //从顶点 u 出发构造网的从顶点最小生成树
int adjve*[100] ;
int dist[100];
bool visited[100];
int i; // 辅助数组初始化
for( i=0; i<ve*num; i++)
{
adjve*[i]=u;
dist[i]=mat[u][i];
}
fill(visited, visited+ve*num, false);
visited[u] = true; // 初始，U＝{u} 初始，＝
for(int v=1; v<=ve*num-1; v++)
{
// 选择 ve*num-1 个顶点边) 个顶点(边
int k=MinVerte*(dist,visited ); // 参加生成树的下一个顶点 (k)
visited[k] = true; // 新节点加入集合 U
// 调整集合 V-U 中剩余顶点到集合 U 的最短距离
for (i=0; i<ve*num; i++)
{
if (visited[i]==false && mat[k][i]<dist[i])
{
adjve*[i] = k;
dist[i]= mat[k][i];
}
}
}
int cost=0;
dist[u]=0;
for (i = 0; i<ve*num; i++)
{
cost+=dist[i];
}
return cost;
} // 寻找 V-U 中未被访问，且 dist 最小的顶点中未被访问，
int MGraph::MinVerte*(int dist[],bool visited[])
{
int k = -1;
int min=INT_MA*;
for (int i = 0; i<ve*num; i++)
{
if (dist[i] < min && visited[i]==false)
{
min=dist[i];
k = i;
}
}
return k;
}
void MGraph::createGraph(int n, int m)
{
ve*num=n;
for(int v=0; v<ve*num; v++)
{
for (int w=0; w<ve*num; w++)
{
mat[v][w]=INT_MA*;
}
}
for(int i=0; i<m; i++)
{
int a,b,c;
cin>>a>>b>>c;
mat[a][b]=c;
mat[b][a]=c;
}
}
int main()//个顶点(边 // 选择 ve*num-1 个顶点边) {
MGraph G;
int n,m;
cin>>n>>m;
G.createGraph(n,m);
cout<<G.Prim(0)<<endl;
return 0;
}
最小生成树kruskal法1：
//#include "stdaf*.h"
#include<iostream>
#define MA* 100
typedef int WeiType;
using namespace std;//
struct Edge
{
int no; //边的序号
int *;//端点1序号
int y; // 端点2序号
WeiType weight; //权值
bool selected; //是否被选择
};//边集和
Edge edge[MA*];//已找到的最小生成树其中一局部的秩
int rank[MA*];//已找到的最小生成树其中一局部的头结点//用来判断一条边的2个端点是否在一个集合中，即加上这条边是否会形成回路
int parent[MA*];//找出每一集合的头结点
int find_set(int *)
{
if(* != parent[*] )
parent[*] = find_set(parent[*]);
return parent[*];
}//合并集合
void union_set(int *,int y,WeiType w,WeiType &sum)
{
if(*==y)
return;
if(rank[*]>rank[y])
parent[y]=*;
else
{
if(rank[*]==rank[y])
rank[y]++;
parent[*]=y;
}
sum +=w;
}//依据边的权值升序快速排序
void fast_sort(Edge *edge,int begin,int end)
{
if(begin<end)
{
int i = begin-1,j=begin;
edge[0] = edge[end];
while(j<end)
{
if(edge[j].weight<edge[0].weight)
{
i++;
Edge temp1 = edge[i];
edge[i] = edge[j];
edge[j] = temp1;
}
j++;
}
Edge temp2 = edge[end];
edge[end] = edge[i+1];
edge[i+1] = temp2;
fast_sort(edge,begin,i);
fast_sort(edge,i+2,end);
}
}
int main(int argc, char * argv[])
{
int cases;
cout<<"请输入案例的个数：";
cin>>cases;
while(cases--)
{
int n; //最小生成树的权值总和
WeiType sum = 0;
cout<<"请输入边的个数：";
cin>>n;
int i; //初始化
char ch*,chy;
WeiType weight;
for(i=1;i<=n;i++)
{
edge[i].no = i;
cout<<"请输入第"<<i<<"条边的二个端点的名称(小写字符)：";
cin>>ch*>>chy;
edge[i].* = ch*-'a'+1;
edge[i].y = chy-'a'+1;
cout<<"这条边的权值为：";
cin>>weight;
edge[i].weight = weight;
edge[i].selected = false;
parent[edge[i].*] = edge[i].*;
parent[edge[i].y] = edge[i].y;
rank[edge[i].*] = 0;
rank[edge[i].y] = 0;
} //快排
fast_sort(edge,1,n);
for(i=1;i<=n;i++)
{
int *,y;
* = find_set(edge[i].*);
y = find_set(edge[i].y); //判断即加上这条边是否会形成回路
if(* != y )
{
//选择这条边
edge[i].selected = true;
//合并不会形成回路的二个集合
union_set(*,y,edge[i].weight,sum);
}
}
cout<<"最小生成树的边集为："<<endl; for(i=1;i<=n;i++)
{
if(edge[i].selected)
{
cout<<"序号："<<edge[i].no<<" " <<"端点1："<<(char)(edge[i].*+'a'-1)<<",端点2："<<(char)(edge[i].y+'a'-1)<<endl;
}
}
cout<<"最小生成树的权值为："<<sum<<endl;
}
system("pause");
return 0;
}
最小生成树prim法2：
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#define MA*_NAME 5
#define MA*_VERTE*_NUM 20
typedef char Verte*[MA*_NAME];/*顶点名字串*/
typedef int AdjMatri*[MA*_VERTE*_NUM][MA*_VERTE*_NUM];/*邻接距阵*/
struct MGraph/*定义图*/
{
Verte* ve*s[MA*_VERTE*_NUM];
AdjMatri* arcs;
int ve*num,arum;
};
typedef struct
{
Verte* adjve*;/*当前点*/
int lowcost;/*代价*/
}
minside[MA*_VERTE*_NUM];
int LocateVe*(MGraph G,Verte* u)//定位
{
int i;
for(i=0;i<G.ve*num;++i)
if(strcmp(u,G.ve*s[i])==0)
return i;
return-1;
}。