nump編程

A. 並行計算，有沒有人會這個

我會。

入門的話推薦你學習下MPI編程，

目前並行計算基本上有:MPI、OPENMP、OPENCL、OPENGL、CUDA

你只是想體驗的話用OPENMP最省事了，一句話就可以達到並行的效果

代碼我可以給你，但你要配好環境。先給你裸敲一個hello world的MPI程序吧

#include<stdio.h>
#include<mpi.h>
intmain(intargc，char*argv[])
{
intmypid,numprocs;
MPI_Init(&argc,&argv);//並行開始
MPI_Comm_size(MPI_COMM_WORLD,&numprocs);//獲取進程數
MPI_Comm_rank(MPI_COMM_WORLD,&mypid);//獲取本進程ID號
printf("helloworld!iam%dprocessof%dprocesses",mypid,numporcs);
MPI_Finalize();//並行結束
}

這就是MPI版的hello world 程序，你需要在編譯的時候確定同時打開幾個進程，比如說4個，程序可能運行結果為：

hello world! i am 2 process of 4 processes

hello world! i am 1 process of 4 processes

hello world! i am 0 process of 4 processes

hello world! i am 3 process of 4 processes

為什麼說可能呢，因為四個進程同時在執行上面的那段代碼，哪個進程先結束哪個就先輸出就這個道理。

想學並行編程的話，建議你在linux下學習。

望採納

B. xwiki為什麼還支持python

系統編程：提供API（Application Programming Interface應用程序編程介面），能方便進行系統維護和管理，Linux下標志性語言之一，是很多系統管理員理想的編程工具。 圖形處理：有PIL、Tkinter等圖形庫支持，能方便進行圖形處理。 數學處理：NumP...

C. 用匯編語言編寫程序，將一個包含有20個數據的數組N分成兩組：正數數組P和負數數組M，並顯示個數。

;在數據段自行定義一個包含10個位元組數據的數組M,將數組分成兩個數組,正數數組P和負數數組N.

data segment

num dw 01h,02h,03h,04h,05h,06h,07h,10h,20h,30h

nump dw ?

count equ $-num

data ends

stack segment para stack

dw 20h p(0)

stack ends

code segment

assume ds:data,cs:code,ss:stack

start: mov ax,data

mov ds,ax

mov cx,0

mov bx,0

mov ax,num[bx]

cmp ax,0

js end0

mov nump[bx],ax

inc bx

inc cx

end0: mov numn[bx],ax

inc bx

inc cx

mov ah,40h

int 21h

end start

code ends

D. 高分懸賞java程序，急！！！

import java.awt.*;
import java.awt.event.*;
//俄羅斯方塊類
public class ERS_Block extends Frame{
public static boolean isPlay=false;
public static int level=1,score=0;
public static TextField scoreField,levelField;

public static MyTimer timer;
GameCanvas gameScr;

public static void main(String[] argus){
ERS_Block ers = new ERS_Block("俄羅斯方塊游戲 V1.0 Author:Vincent");
WindowListener win_listener = new WinListener();
ers.addWindowListener(win_listener);
}

//俄羅斯方塊類的構造方法
ERS_Block(String title){
super(title);

setSize(600,480);
setLayout(new GridLayout(1,2));

gameScr = new GameCanvas();
gameScr.addKeyListener(gameScr);

timer = new MyTimer(gameScr);
timer.setDaemon(true);
timer.start();
timer.suspend();

add(gameScr);

Panel rightScr = new Panel();
rightScr.setLayout(new GridLayout(2,1,0,30));
rightScr.setSize(120,500);
add(rightScr);

//右邊信息窗體的布局
MyPanel infoScr = new MyPanel();
infoScr.setLayout(new GridLayout(4,1,0,5));
infoScr.setSize(120,300);
rightScr.add(infoScr);

//定義標簽和初始值
Label scorep = new Label("分數:",Label.LEFT);
Label levelp = new Label("級數:",Label.LEFT);
Label namep = new Label("姓名：張三",Label.LEFT);
Label nump = new Label("學號:110821332",Label.LEFT);
scoreField = new TextField(8);
levelField = new TextField(8);
scoreField.setEditable(false);
levelField.setEditable(false);
infoScr.add(namep);
infoScr.add(nump);
infoScr.add(scorep);
infoScr.add(scoreField);
infoScr.add(levelp);
infoScr.add(levelField);
scorep.setSize(new Dimension(20,60));
scoreField.setSize(new Dimension(20,60));
levelp.setSize(new Dimension(20,60));
levelField.setSize(new Dimension(20,60));
scoreField.setText("0");
levelField.setText("1");

//右邊控制按鈕窗體的布局
MyPanel controlScr = new MyPanel();
controlScr.setLayout(new GridLayout(5,1,0,5));
rightScr.add(controlScr);

//定義按鈕play
Button play_b = new Button("開始游戲");
play_b.setSize(new Dimension(50,200));
play_b.addActionListener(new Command(Command.button_play,gameScr));

//定義按鈕Level UP
Button level_up_b = new Button("提高級數");
level_up_b.setSize(new Dimension(50,200));
level_up_b.addActionListener(new Command(Command.button_levelup,gameScr));

//定義按鈕Level Down
Button level_down_b =new Button("降低級數");
level_down_b.setSize(new Dimension(50,200));
level_down_b.addActionListener(new Command(Command.button_leveldown,gameScr));

//定義按鈕Level Pause
Button pause_b =new Button("游戲暫停");
pause_b.setSize(new Dimension(50,200));
pause_b.addActionListener(new Command(Command.button_pause,gameScr));

//定義按鈕Quit
Button quit_b = new Button("退出遊戲");
quit_b.setSize(new Dimension(50,200));
quit_b.addActionListener(new Command(Command.button_quit,gameScr));

controlScr.add(play_b);
controlScr.add(level_up_b);
controlScr.add(level_down_b);
controlScr.add(pause_b);
controlScr.add(quit_b);
setVisible(true);
gameScr.requestFocus();
}
}

//重寫MyPanel類，使Panel的四周留空間
class MyPanel extends Panel{
public Insets getInsets(){
return new Insets(30,50,30,50);
}
}

//游戲畫布類
class GameCanvas extends Canvas implements KeyListener{
final int unitSize = 30; //小方塊邊長
int rowNum; //正方格的行數
int columnNum; //正方格的列數
int maxAllowRowNum; //允許有多少行未削
int blockInitRow; //新出現塊的起始行坐標
int blockInitCol; //新出現塊的起始列坐標
int [][] scrArr; //屏幕數組
Block b; //對方快的引用

//畫布類的構造方法
GameCanvas(){
rowNum = 15;
columnNum = 10;
maxAllowRowNum = rowNum - 2;
b = new Block(this);
blockInitRow = rowNum - 1;
blockInitCol = columnNum/2 - 2;
scrArr = new int [32][32];
}

//初始化屏幕，並將屏幕數組清零的方法
void initScr(){
for(int i=0;i<rowNum;i++)
for (int j=0; j<columnNum;j++)
scrArr[i][j]=0;
b.reset();
repaint();
}

//重新刷新畫布方法
public void paint(Graphics g){
for(int i = 0; i < rowNum; i++)
for(int j = 0; j < columnNum; j++)
drawUnit(i,j,scrArr[i][j]);
}

//畫方塊的方法
public void drawUnit(int row,int col,int type){
scrArr[row][col] = type;
Graphics g = getGraphics();
switch(type){ //表示畫方快的方法
case 0: g.setColor(Color.black);break; //以背景為顏色畫
case 1: g.setColor(Color.blue);break; //畫正在下落的方塊
case 2: g.setColor(Color.magenta);break; //畫已經落下的方法
}
g.fill3DRect(col*unitSize,getSize().height-(row+1)*unitSize,unitSize,unitSize,true);
g.dispose();
}

public Block getBlock(){
return b; //返回block實例的引用
}

//返回屏幕數組中(row,col)位置的屬性值
public int getScrArrXY(int row,int col){
if (row < 0 || row >= rowNum || col < 0 || col >= columnNum)
return(-1);
else
return(scrArr[row][col]);
}

//返回新塊的初始行坐標方法
public int getInitRow(){
return(blockInitRow); //返回新塊的初始行坐標
}

//返回新塊的初始列坐標方法
public int getInitCol(){
return(blockInitCol); //返回新塊的初始列坐標
}

//滿行刪除方法
void deleteFullLine(){
int full_line_num = 0;
int k = 0;
for (int i=0;i<rowNum;i++){
boolean isfull = true;

L1:for(int j=0;j<columnNum;j++)
if(scrArr[i][j] == 0){
k++;
isfull = false;
break L1;
}
if(isfull) full_line_num++;
if(k!=0 && k-1!=i && !isfull)
for(int j = 0; j < columnNum; j++){
if (scrArr[i][j] == 0)
drawUnit(k-1,j,0);
else
drawUnit(k-1,j,2);
scrArr[k-1][j] = scrArr[i][j];
}
}
for(int i = k-1 ;i < rowNum; i++){
for(int j = 0; j < columnNum; j++){
drawUnit(i,j,0);
scrArr[i][j]=0;
}
}
ERS_Block.score += full_line_num;
ERS_Block.scoreField.setText(""+ERS_Block.score);
}

//判斷游戲是否結束方法
boolean isGameEnd(){
for (int col = 0 ; col <columnNum; col ++){
if(scrArr[maxAllowRowNum][col] !=0)
return true;
}
return false;
}

public void keyTyped(KeyEvent e){
}

public void keyReleased(KeyEvent e){
}

//處理鍵盤輸入的方法
public void keyPressed(KeyEvent e){
if(!ERS_Block.isPlay)
return;
switch(e.getKeyCode()){
case KeyEvent.VK_DOWN:b.fallDown();break;
case KeyEvent.VK_LEFT:b.leftMove();break;
case KeyEvent.VK_RIGHT:b.rightMove();break;
case KeyEvent.VK_SPACE:b.leftTurn();break;
}
}
}

//處理控制類
class Command implements ActionListener{
static final int button_play = 1; //給按鈕分配編號
static final int button_levelup = 2;
static final int button_leveldown = 3;
static final int button_quit = 4;
static final int button_pause = 5;
static boolean pause_resume = true;

int curButton; //當前按鈕
GameCanvas scr;

//控制按鈕類的構造方法
Command(int button,GameCanvas scr){
curButton = button;
this.scr=scr;
}

//按鈕執行方法
public void actionPerformed (ActionEvent e){
switch(curButton){
case button_play:if(!ERS_Block.isPlay){
scr.initScr();
ERS_Block.isPlay = true;
ERS_Block.score = 0;
ERS_Block.scoreField.setText("0");
ERS_Block.timer.resume();
}
scr.requestFocus();
break;
case button_levelup:if(ERS_Block.level < 10){
ERS_Block.level++;
ERS_Block.levelField.setText(""+ERS_Block.level);
ERS_Block.score = 0;
ERS_Block.scoreField.setText(""+ERS_Block.score);
}
scr.requestFocus();
break;
case button_leveldown:if(ERS_Block.level > 1){
ERS_Block.level--;
ERS_Block.levelField.setText(""+ERS_Block.level);
ERS_Block.score = 0;
ERS_Block.scoreField.setText(""+ERS_Block.score);
}
scr.requestFocus();
break;
case button_pause:if(pause_resume){
ERS_Block.timer.suspend();
pause_resume = false;
}else{
ERS_Block.timer.resume();
pause_resume = true;
}
scr.requestFocus();
break;
case button_quit:System.exit(0);
}
}
}

//方塊類
class Block {
static int[][] pattern = {
{0x0f00,0x4444,0x0f00,0x4444},//用十六進至表示，本行表示長條四種狀態
{0x04e0,0x0464,0x00e4,0x04c4},
{0x4620,0x6c00,0x4620,0x6c00},
{0x2640,0xc600,0x2640,0xc600},
{0x6220,0x1700,0x2230,0x0740},
{0x6440,0x0e20,0x44c0,0x8e00},
{0x0660,0x0660,0x0660,0x0660}
};
int blockType; //塊的模式號（0-6）
int turnState; //塊的翻轉狀態（0-3）
int blockState; //快的下落狀態
int row,col; //塊在畫布上的坐標
GameCanvas scr;

//塊類的構造方法
Block(GameCanvas scr){
this.scr = scr;
blockType = (int)(Math.random() * 1000)%7;
turnState = (int)(Math.random() * 1000)%4;
blockState = 1;
row = scr.getInitRow();
col = scr.getInitCol();
}

//重新初始化塊，並顯示新塊
public void reset(){
blockType = (int)(Math.random() * 1000)%7;
turnState = (int)(Math.random() * 1000)%4;
blockState = 1;
row = scr.getInitRow();
col = scr.getInitCol();
dispBlock(1);
}

//實現「塊」翻轉的方法
public void leftTurn(){
if(assertValid(blockType,(turnState + 1)%4,row,col)){
dispBlock(0);
turnState = (turnState + 1)%4;
dispBlock(1);
}
}

//實現「塊」的左移的方法
public void leftMove(){
if(assertValid(blockType,turnState,row,col-1)){
dispBlock(0);
col--;
dispBlock(1);
}
}

//實現塊的右移
public void rightMove(){
if(assertValid(blockType,turnState,row,col+1)){
dispBlock(0);
col++;
dispBlock(1);
}
}

//實現塊落下的操作的方法
public boolean fallDown(){
if(blockState == 2)
return(false);
if(assertValid(blockType,turnState,row-1,col)){
dispBlock(0);
row--;
dispBlock(1);
return(true);
}else{
blockState = 2;
dispBlock(2);
return(false);
}
}

//判斷是否正確的方法
boolean assertValid(int t,int s,int row,int col){
int k = 0x8000;
for(int i = 0; i < 4; i++){
for(int j = 0; j < 4; j++){
if((int)(pattern[t][s]&k) != 0){
int temp = scr.getScrArrXY(row-i,col+j);
if (temp<0||temp==2)
return false;
}
k = k >> 1;
}
}
return true;
}

//同步顯示的方法
public synchronized void dispBlock(int s){
int k = 0x8000;
for (int i = 0; i < 4; i++){
for(int j = 0; j < 4; j++){
if(((int)pattern[blockType][turnState]&k) != 0){
scr.drawUnit(row-i,col+j,s);
}
k=k>>1;
}
}
}
}

//定時線程
class MyTimer extends Thread{
GameCanvas scr;

public MyTimer(GameCanvas scr){
this.scr = scr;
}

public void run(){
while(true){
try{
sleep((10-ERS_Block.level + 1)*100);
}
catch(InterruptedException e){}
if(!scr.getBlock().fallDown()){
scr.deleteFullLine();
if(scr.isGameEnd()){
ERS_Block.isPlay = false;
suspend();
}else
scr.getBlock().reset();
}
}
}
}

class WinListener extends WindowAdapter{
public void windowClosing (WindowEvent l){
System.exit(0);
}
}

E. c++開根號函數

sqrt(num);表示求根號num;

pow(x,y);表示求x的y次方；

例如：

//參考代碼如下：

//做到前後標簽匹配

#include"iostream"

#include"stdlib.h"

#include"math.h"

usingnamespacestd;

intmain()

{

doublenum,s,p,n=3;

cin>>num;//輸入num

s=sqrt(num);//求根號num

p=pow(num,n);//求num的3次方

cout<<s<<""<<p<<endl;

return0;

}

/*

運行結果：

4

264

*/

資料拓展

C++是一種面向對象的計算機程序設計語言，由美國AT&T貝爾實驗室的本賈尼·斯特勞斯特盧普博士在20世紀80年代初期發明並實現（最初這種語言被稱作「C with Classes」帶類的C）。

它是一種靜態數據類型檢查的、支持多重編程範式的通用程序設計語言。它支持過程化程序設計、數據抽象、面向對象程序設計、泛型程序設計等多種程序設計風格。

[1]C++是C語言的繼承，進一步擴充和完善了C語言，成為一種面向對象的程序設計。

F. 集群mpirun並行,把同樣的任務重復跑了幾十遍

我會。入門的話你學習下MPI編程，目前並行計算基本上有:MPI、OPENMP、OPENCL、OPENGL、CUDA你只是想體驗的話用OPENMP最省事了，一句話就可以達到並行的效果代碼我可以給你，但你要配好環境。先給你裸敲一個hello world的MPI程序吧<pre t="code" l="cpp">includelt;stdio.h;
includelt;mpi.h;
int main (int argc，char *argv[])
{
int mypid ,numprocs;
MPI_Init(amp;argc,amp;argv); // 並行開始
MPI_Comm_size(MPI_COMM_WORLD,amp;numprocs); //獲取進程數
MPI_Comm_rank(MPI_COMM_WORLD,amp;mypid); //獲取本進程ID號
printf(hello world! i am %d process of %d processes,mypid,numporcs);
MPI_Finalize(); //並行結束
}這就是MPI版的hello world 程序，你需要在編譯的時候確定同時打開幾個進程，比如說4個，程序可能運行結果為：hello world! i am 2 process of 4 processeshello world! i am 1 process of 4 processeshello world! i am 0 process of 4 processeshello world! i am 3 process of 4 processes為什麼說可能呢，因為四個進程同時在執行上面的那段代碼，哪個進程先結束哪個就先輸出就這個道理。想學並行編程的話，建議你在linux下學習。

G. 安全生產中nump是指啥

科學計算的基礎包。

_它是一個開源的 Python 擴展庫，用來支持大數據量的高維數組和矩陣運算，比 Python 自身的嵌套列表（該結構也可以用來表示矩陣）結構要高效的多。

_NumPy 提供了許多高級的數值編程工具，比如矩陣數據類型、矢量處理、高精度運算等，它專為嚴格的數字處理而產生。多為很多大型金融公司使用，以及核心的科學計算組織（比如 Lawrence Livermore、NASA）都使用 NumPy 來處理一些本來使用 C++、Fortran 或 Matlab 等所做的任務。

H. C++ 編程error 不會改求救！！！

if (nameEntered=lastname[i][j])

應該是
if (nameEntered==lastname[i][j])

=是賦值
==是判斷相等，你粗心了

I. 動態規劃的應用

記憶化
給你一個數字三角形, 形式如下:
1
2 3
4 5 6
7 8 9 10
找出從第一層到最後一層的一條路,使得所經過的權值之和最小或者最大.
無論對於新手還是老手，這都是再熟悉不過的題了，很容易地，我們寫出狀態轉移方程：
f[i][j]=a[i][j] + min{f[i+1][j]，f[i+1][j+1]}(a[i][j]表示當前狀態,f[i][j]表示指標函數)
對於動態規劃演算法解決這個問題，我們根據狀態轉移方程和狀態轉移方向，比較容易地寫出動態規劃的循環表示方法。但是，當狀態和轉移非常復雜的時候，也許寫出循環式的動態規劃就不是那麼簡單了。
解決方法：
我們嘗試從正面的思路去分析問題，如上例，不難得出一個非常簡單的遞歸函數: intf(inti,intj,int(*a)[4]){intf1,f2,tmp=0,k;if(i==0||j==0)returna[0][0];if(j==i){for(k=0;k<=i;k++)tmp+=a[k][k];returntmp;}f1=f(i-1,j,a);f2=f(i-1,j-1,a);if(f1<f2)returnf2+a[i][j];elsereturnf1+a[i][j];}顯而易見，這個演算法就是最簡單的搜索演算法。時間復雜度為2^n，明顯是會超時的。分析一下搜索的過程，實際上，很多調用都是不必要的，也就是把產生過的最優狀態，又產生了一次。為了避免浪費，很顯然，我們存放一個opt數組：Opt[i, j] - 每產生一個f(i, j)，將f(i, j)的值放入opt中，以後再次調用到f(i, j)的時候，直接從opt[i, j]來取就可以了。於是動態規劃的狀態轉移方程被直觀地表示出來了，這樣節省了思維的難度，減少了編程的技巧，而運行時間只是相差常數的復雜度，避免了動態規劃狀態轉移先後的問題，而且在相當多的情況下，遞歸演算法能更好地避免浪費，在比賽中是非常實用的。
並且記憶搜索占的內存相對來說較少。
計算核心片段： for(inti=n-1;i>=1;--i)//從倒數第二行開始{for(intj=1;j<=i;j++){if(a[i+1][j][1]>a[i+1][j+1][1])//左邊大{a[i][j][2]=0;//選擇左邊a[i][j][1]+=a[i+1][j][1];}else//右邊大{a[i][j][2]=1;//選擇右邊a[i][j][1]+=a[i+1][j+1][1];}練習題
USACO2.2 Subset Sums
題目如下：
對於從1到N的連續整數集合，能劃分成兩個子集合，且保證每個集合的數字和是相等的。
舉個例子，如果N=3，對於{1，2，3}能劃分成兩個子集合，他們每個的所有數字和是相等的：
{3}and {1,2}
這是唯一一種分法（交換集合位置被認為是同一種劃分方案，因此不會增加劃分方案總數）
如果N=7，有四種方法能劃分集合{1，2，3，4，5，6，7}，每一種分發的子集合各數字和是相等的:
{1,6,7} and {2,3,4,5} {注 1+6+7=2+3+4+5}
{2,5,7} and {1,3,4,6}
{3,4,7} and {1,2,5,6}
{1,2,4,7} and {3,5,6}
給出N，你的程序應該輸出劃分方案總數，如果不存在這樣的劃分方案，則輸出0。程序不能預存結果直接輸出。
PROGRAM NAME: subset
INPUT FORMAT
輸入文件只有一行，且只有一個整數N
SAMPLE INPUT (file subset . in)
7
OUTPUT FORMAT
輸出劃分方案總數，如果不存在則輸出0。
SAMPLE OUTPUT (file subset.out)
4
參考程序如下（C++語言）： #include<fstream>usingnamespacestd;constunsignedintMAX_SUM=1024;intn;unsignedlonglongintdyn[MAX_SUM];ifstreamfin(subset.in);ofstreamfout(subset.out);intmain(){fin>>n;fin.close();ints=n*(n+1);if(s%4){fout<<0<<endl;fout.close();return0;}s/=4;inti,j;dyn[0]=1;for(i=1;i<=n;i++)for(j=s;j>=i;j--)if(j-i>0){dyn[j]+=dyn[j-i];}fout<<(dyn[s]/2)<<endl;fout.close();return0;}USACO2.3LongestPrefix題目如下：
在生物學中，一些生物的結構是用包含其要素的大寫字母序列來表示的。生物學家對於把長的序列分解成較短的（稱之為元素的）序列很感興趣。
如果一個集合 P 中的元素可以通過並運算（允許重復；並，即∪，相當於 Pascal 中的 「+」 運算符）組成一個序列 S ，那麼我們認為序列 S 可以分解為 P 中的元素。並不是所有的元素都必須出現。舉個例子，序列 ABABACABAAB 可以分解為下面集合中的元素：
{A, AB, BA, CA, BBC}
序列 S 的前面 K 個字元稱作 S 中長度為 K 的前綴。設計一個程序，輸入一個元素集合以及一個大寫字母序列，計算這個序列最長的前綴的長度。
PROGRAM NAME: prefix
INPUT FORMAT
輸入數據的開頭包括 1..200 個元素（長度為 1..10 ）組成的集合，用連續的以空格分開的字元串表示。字母全部是大寫，數據可能不止一行。元素集合結束的標志是一個只包含一個 「.」 的行。集合中的元素沒有重復。接著是大寫字母序列 S ，長度為 1..200,000 ，用一行或者多行的字元串來表示，每行不超過 76 個字元。換行符並不是序列 S 的一部分。
SAMPLE INPUT (file prefix. in)
A AB BA CA BBC
.
ABABACABAABC
OUTPUT FORMAT
只有一行，輸出一個整數，表示 S 能夠分解成 P 中元素的最長前綴的長度。
SAMPLE OUTPUT (file prefix.out)
11
示常式序如下：
#include <stdio.h>
#define MAXP 200
#define MAXL 10
char prim[MAXP+1][MAXL+1];
int nump;
int start[200001];
char data[200000];
int ndata;
int main(int argc, char **argv)
{
FILE *fout, *fin;
int best;
int lv,lv2, lv3;
if ((fin = fopen(prim. in, r)) == NULL)
{
perror (fopen fin);
exit(1);
}
if((fout = fopen(prim.out, w)) == NULL)
{
perror (fopen fout);
exit(1);
}
while (1)
{
fscanf (fin, %s, prim[nump]);
if (prim[nump][0] != '.')
nump++;
else
break;
}
ndata = 0;
while (fscanf (fin, %s, data+ndata) == 1)
ndata += strlen(data+ndata);
start[0] = 1;
best = 0;
for (lv = 0; lv < ndata; lv++)
if (start[lv])
{
best = lv;
for (lv2 = 0; lv2 < nump; lv2++)
{
for (lv3 = 0; lv + lv3 < ndata && prim[lv2][lv3] == data[lv+lv3]; lv3++)
if (!prim[lv2][lv3])
start[lv + lv3] = 1;
}
}
if (start[ndata])
best = ndata;
fprintf (fout, %i , best);
return 0;
}
動態規劃作為一種重要的信息學競賽演算法，具有很強的靈活性。以上提供的是一些入門練習題，深入的學習還需要逐步積累經驗。
解決0-1背包問題時使用動態規劃的實現（c++）
#include <stdio.h>
typedef struct Object{
int weight;
int value; // float rate;
}
Object;
Object * array; //用來存儲物體信息的數組
int num; //物體的個數
int container; //背包的容量
int ** dynamic_table; //存儲動態規劃表
bool * used_table; //存儲物品的使用情況
//ouput the table of dynamic programming, it's for detection
void print_dynamic_table(){
printf(動態規劃表如下所示: );
/* for(int j=0; j<=container; j++) printf(%d ,j); printf( );*/
for(int i=1; i<=num; i++) {
for(int j=0; j<=container; j++)
printf(%d ,dynamic_table[i][j]);
printf( );
}
}
//列印動態規劃表
void print_array(){
for(int i=1; i<=num; i++)
printf(第%d個物品的重量和權重:%d %d ,i,array[i].weight,array[i].value);
}
//列印輸入的物品情況//插入排序，按rate=value/weight由小到大排//動態規劃考慮了所有情況，所以可以不用排序
/*void sort_by_rate(){
for(int i=2; i<=num; i++) {
Object temp=array[i];
for(int j=i-1; j>=1; j--)
if(array[j].rate>temp.rate)
array[j+1]=array[j];
else break;
array[j+1]=temp;
}}*/
void print_used_object(){
printf(所使用的物品如下所示: );
for(int i=1; i<=num; i++)
if(used_table[i]==1)
printf(%d-%d , array[i].weight, array[i].value);
}
//列印物品的使用情況
/* 做測試時使用
void print_used_table(bool * used_table){
printf(used table as follows: );
for(int i=1; i<=num; i++)
printf(object %d is %d, i, used_table[i]);
}*/
void init_problem(){
printf(輸入背包的容量: );
scanf(%d, &container);
printf(輸入物品的個數: );
scanf(%d, &num);
array=new Object[num+1];
printf(輸入物品的重量和價值, 格式如：4-15 );
for(int i=1; i<=num; i++) {
char c;
scanf(%d%c%d, &array[i].weight, &c, &array[i].value);
// array[i].rate=array[i].value/array[i].weight;
}
print_array();
}
//對物體的使用情況進行回查
void trace_back(){
int weight=container;
used_table=new bool[num+1];
for(int i=1; i<=num; i++) used_table[i]=0;
//initalize the used_table to be non-used
for(int j=1; j<num; j++) {
//說明物品j被使用
if(dynamic_table[j][weight]!=dynamic_table[j+1][weight]) {
weight-=array[j].weight;
used_table[j]=1;
}
// print_used_table(used_table);
}
//檢測第num個物品是否被使用
if(weight>=array[num].weight)
used_table[num]=1;
}
void dynamic_programming(){
dynamic_table=new int * [num+1];
for(int k=1; k<=num; k++)
dynamic_table[k]=new int[container+1];
//dynamic_programming table
//為二維動態規劃表分配內存
for(int m=1; m<num; m++)
for(int n=0; n<=container; n++)
dynamic_table[m][n]=0;
int temp_weight=array[num].weight;
for(int i=0; i<=container; i++)
dynamic_table[num][i]=i<temp_weight?0:array[num].value;
//初始化動態規劃表
for(int j=num-1; j>=1; j--) {
temp_weight=array[j].weight;
int temp_value=array[j].value;
for(int k=0; k<=container; k++)
if(k>=temp_weight && dynamic_table[j+1][k] < dynamic_table[j+1][k-temp_weight]+temp_value)
dynamic_table[j][k]=dynamic_table[j+1][k-temp_weight]+temp_value;
else dynamic_table[j][k]=dynamic_table[j+1][k];
}//構建動態規劃表
print_dynamic_table();//列印動態規劃表
}
void main(){
init_problem();
dynamic_programming();
trace_back();
print_used_object();
}