【算法】程序填空

(1)d[v]>d[u]+w(u,v)
(2)Init-single-source(G,s)
(3)Φ
(4)Relax(u,v,w)

(5)m[n][j]=0;
(6)m[i+1][j]
(7)m[i+1][j],m[i+1][j-w[i]]+v[i]
(8)c>=w[1]

给定n种物品和一个背包，物品i的重量是w[i], 其价值是p[i], 背包的容量为c。设物品已按单位重量价值递减的次序排序。每种物品不可以装入背包多次，但可以装入部分的物品i。求解背包问题的贪心算法如下：

float Knapsack (float x[ ], float w[ ], float p[ ],float c, int n)  

{ float maxsum=     1      ;   // maxsum表示装进包的物品价值总和               

for ( int i=1;i<=n; i++)  x[i]=0 // x[i]=0表示第i个物品未装进包         

for (            2             )                        

         if(        3        )                                

{ x[i] =1;                                 

             maxsum+=       4      ;                           

             c- = w[i];                                

       }

         else break;                               

if (c>0) {x[i]=c/w[i];         5          ;}      

return maxsum;                             

}

０

int i=1；i<=n；ｉ++

w[i]<=C

p[i]

maxsum+ = p[i] * c / w[i]

---

三、算法填空

1.背包问题的贪心算法

void Knapsack(int n,float M,float v[],float w[],float x[])

{

       Sort(n,v,w);

       int i;

       for (i=1;i<=n;i++) x[i]=0;

       float c=M;

       for (i=1;i<=n;i++) {

          if (w[i]>c) break;

          x[i]=1;

          **c - =w[i];**

          }

       if (i<=n) **x[i]=c/w[i];**

}

2.最大子段和: 动态规划算法

int MaxSum(int n, int a[])

{

    int sum=0, b=0；   //sum存储当前最大的b[j], b存储b[j]

    for(int j=1； j<=n； j++)  { 

        if (b>0)  b+= a[j] ；

        **else  b=a[i];**     ；    //一旦某个区段和为负，则从下一个位置累和

 if(b>sum) **sum=b;**

 

     }

     return sum；

 }        

3.贪心算法求装载问题

template<class Type>

void Loading(int x[],  Type w[], Type c, int n)

{

        int *t = new int [n+1];

                             **加粗样式**;

        for (int i = 1; i <= n; i++) x[i] = 0;

        for (int i = 1; i <= n && w[t[i]] <= c; i++)

 {x[t[i]] = 1;

          **加粗样式** ;}

}

4.贪心算法求活动安排问题

template<class Type>

void GreedySelector(int n, Type s[], Type f[], bool A[])

{

       **A[1]=true;**

       int j=1;

       for (int i=2;i<=n;i++) {

          if (s[i]>=f[j])

		{  
			**A[i]=true;**

			**j=i;**

 }

          else A[i]=false;

          }

}

 

5.快速排序

template<class Type>

void QuickSort (Type a[], int p, int r)

{

      if (p<r) {

        int q=Partition(a,p,r);

        QuickSort (a,p,q-1); //对左半段排序

        QuickSort (a,q+1,r); //对右半段排序

        }

}

 

6.排列问题

Template <class Type>

void perm(Type list[],  int k, int m )

{ //产生[list[k:m]的所有排列

    **if(k==m)**

     {  //只剩下一个元素

         for (int i=0;i<=m;i++)  cout<<list[i];

         cout<<endl;

    }

    else  //还有多个元素待排列，递归产生排列

       **for (int i=k; i<=m; i++)**

        {

           swap(list[k]，list[i]);

           **perm(list,k+1;m);**

           swap(list[k],list[i]);        

     }

  }