2.4学习周结

栈

栈是限定仅在表尾进行插入和删除操作的线性表。允许去插入和删除的一端叫做栈顶，另一端称为栈底，不含任何元素的栈称为空栈，是后进先出的线性表。

栈的主要操作

1. 进栈（Push）：将元素插入到栈顶。
2. 出栈（Pop）：将栈顶元素删除并返回。
3. 获取栈顶元素（Top）：返回栈顶元素的值，但不对栈做任何修改。
4. 判空（isEmpty）：判断栈是否为空栈。
5. 获取栈的大小（getSize）：返回栈中元素的个数。

栈的顺序存储结构

栈的顺序存储结构可描述为： 

#define MAXSIZE 50  //定义栈中元素的最大个数
typedef struct
{
    int data[MAXSIZE];
    int top;        //用于栈顶指针
}SqStack;

初始化

void InitStack(SqStack *s)
{
    s->top=-1;    //栈顶指针初始化为-1，表示栈为空
}

判栈空

int StackEmpty(SqStack *s)
{
    if(s->top==-1)
        return 0;   //栈空
    else return -1; 
}

进栈

int Push(SqStack *s, ElemType e)
{
    //满栈
    if(s->top==MAXSIZE-1)
        return -1;
    s->top++;   //栈顶指针加1
    s->data[s->top]=e;    //将新插入元素赋值给栈顶空间
    return 0;
}

出栈

int Pop(SqStack *s, ElemType *e)
{
    if(s->top==-1)
        return -1;  //栈空
    *e=s->data[s->top];   //将要删除的栈顶元素赋值给e
    s->top--;   //栈顶指针减1
    return 0;
}

读栈顶元素

int GetTop(SqStack *s, ElemType *e)
{
    if(s->top==-1)   //栈空
        return -1;
    *e=s->data[s->top];   //记录栈顶元素
    return 0;
}

共享栈

利用栈底位置相对不变的特征，可让两个顺序栈共享一个一维数组空间，将两个栈的栈底分别设置在共享空间的两端，两个栈顶向共享空间的中间延伸。

共享栈的数据结构可以描述为：

#define MAXSIZE 50
typedef struct 
{
    int data[MAXSIZE];
    int top1;  // 第一个栈的栈顶指针
    int top2;  // 第二个栈的栈顶指针
}SharedStack;

共享栈的判断条件

栈空条件：1号栈【top1==-1】；1号栈【top2==MAXSIZE】

栈满条件：top2-top1=1

栈的链式存储结构

链栈

采用链式存储的栈称为链栈，通常采用单链表实现。链栈可以动态地增加和删除元素，不受容量限制，不存在栈满上溢的情况。

栈的链式存储

//构造结点
typedef struct StackNode
{
    int data;
    struct StackNode *next;
}LinkStackPrt;
//构造链栈
typedef struct LinkStack
{
    LinkStackPrt *top;
    int count;
}LinkStack;

队列

队列是只允许在一端进行插入操作，而在另一端进行删除操作的线性表。队列是一种先进先出的线性表。允许插入的一端称为队尾（Rear），允许删除的一端称为队头（Front）。

队列的主要操作

1. 入队（enqueue）：将元素插入到队列的尾部。
2. 出队（dequeue）：从队列的头部删除一个元素。
3. 队列是否为空（isEmpty）：判断队列是否为空。
4. 队列大小（size）：返回队列中元素的个数。
5. 获取队头元素（front）：返回队列的头部元素，但不删除。
6. 清空队列（clear）：清空队列中的所有元素。

队列的顺序存储结构

队列的顺序存储结构可描述为： 

#define MIXSIZE 50
typedef struct 
{
    int data[MIXSIZE];    // 队列的数据存储数组
    int front;            // 队列的头部指针
    int rear;             // 队列的尾部指针
} Queue;

#include 
#define MIXSIZE 50
 
//队列的顺序存储类
typedef struct 
{
    int data[MIXSIZE];    // 队列的数据存储数组
    int front;            // 队列的头部指针
    int rear;             // 队列的尾部指针
} Queue;
 
//初始化队列的指针
void initQueue(Queue *q) 
{
    q->front=q->rear=0;
}
 
// 判断队列是否已满
int isFull(Queue *q) 
{
    if((q->rear+1)%MIXSIZE==q->front)
        return 1;//满
    else return 0;
}
 
// 判断队列是否为空
int isEmpty(Queue *q) 
{
    if(return q->front==q->rear)
        return 1;//空
    else return 0;
}
 
//求队列当前长度
int QueueLength(Queue *q)
{
    return (q.rear-q.front+MAXSIZE)%MAXSIZE;
}
 
 
// 入队操作
void enqueue(Queue *q, int value) 
{
    if(isFull(q)) 
    {
        printf("Queue is full.\n");
        return;
    }
 
    q->data[q->rear]=value;
    q->rear=(q->rear+1)%MIXSIZE;
}
 
// 出队操作
int dequeue(Queue *q) 
{
    if(isEmpty(q)) 
    {
        printf("Queue is empty.\n");
        return -1;
    }
    
    int value=q->data[q->front];
    q->front=(q->front+1)%MIXSIZE;
    return value;
}

队列的链式存储结构

链队列

队列的链式存储结构即为链队列，是一个同时带有队头指针和队尾指针的单链表，只能尾进头出。

1）链队列由结点构成，每个结点包含一个元素和一个指向下一个节点的指针。

2）链队列有两个指针：队首指针和队尾指针。初始时，队首指针和队尾指针都指向空结点。

3）队首指针指向链队列中的第一个结点，队尾指针指向链队列中的最后一个结点。

4）当队列为空时，队首指针和队尾指针都指向空结点。

5）当队列不为空时，队首指针指向队列中的第一个结点，队尾指针指向队列中的最后一个结点。

6）在链队列中插入一个元素时，需要创建一个新结点，并将其插入到队尾节点的后面。

7）在链队列中删除一个元素时，需要删除队首结点，并将队首指针指向下一个节点。

队列的链式存储

// 定义链表节点结构体
typedef struct Node 
{
    int data;           // 数据域
    struct Node* next;  // 指针域
} Node;
 
// 定义链队列结构体
typedef struct 
{
    Node* front;  // 队头指针
    Node* rear;   // 队尾指针
} Queue;

0-1背包问题

0-1背包问题是一个经典的组合优化问题，其问题描述为：有一组物品，每个物品有重量和价值两个属性。现在有一个背包，它能承受的最大重量为W。要求在不超过背包承重的情况下，选择一些物品装入背包，使得装入的物品总价值最大。

思路

该问题的特点是每个物品只有选或不选两种情况，即0-1选择，不能选择部分物品装入。

解决该问题的常用方法是使用动态规划。

二维数组

定义一个二维数组dp[ ][ ]，其中dp[i][j]表示在前i个物品中选择总重量不超过j的情况下的最大总价值。

动态规划的状态转移方程为：

1）若第i个物品的重量大于j，即wi > j，则dp[i][j] = dp[i-1][j]，即当前物品不选；

2）若第i个物品的重量小于等于j，即wi <= j，dp[i][j] = dp[i-1][j]（不选）或 dp[i][j] = dp[i-1][j-wi]+vi（不选），则 dp[i][j] = max ( dp[i-1][j] , dp[i-1][j-wi]+vi )，即当前物品选或不选，选择价值最大的情况。

最终的结果为dp[N][W]，即在前N个物品中选择总重量不超过W的情况下的最大总价值。

一维数组

定义一个二维数组dp[ ]，其中dp[j]表示在选择总重量不超过j的情况下的最大总价值。

动态规划的状态转移方程为：

1）若第i个物品的重量大于j，即wi > j，则dp[j] = dp[j]，即当前物品不选；

2）若第i个物品的重量小于等于j，即wi <= j，dp[j] = dp[j]（不选）或 dp[j] = dp[j-wi]+vi（不选），则 dp[j] = max ( dp[j] , dp[j-wi]+vi )，即当前物品选或不选，选择价值最大的情况。

最终的结果为dp[W]，即在选择总重量不超过W的情况下的最大总价值。

 题目描述

辰辰是个天资聪颖的孩子，他的梦想是成为世界上最伟大的医师。为此，他想拜附近最有威望的医师为师。医师为了判断他的资质，给他出了一个难题。医师把他带到一个到处都是草药的山洞里对他说：“孩子，这个山洞里有一些不同的草药，采每一株都需要一些时间，每一株也有它自身的价值。我会给你一段时间，在这段时间里，你可以采到一些草药。如果你是一个聪明的孩子，你应该可以让采到的草药的总价值最大。”

如果你是辰辰，你能完成这个任务吗？

输入格式

第一行有 2 个整数 T（1≤T≤1000）和 （1≤M≤100），用一个空格隔开，T 代表总共能够用来采药的时间，M 代表山洞里的草药的数目。

接下来的 M 行每行包括两个在 1 到 100 之间（包括 1 和 100）的整数，分别表示采摘某株草药的时间和这株草药的价值。

输出格式

输出在规定的时间内可以采到的草药的最大总价值。

输入输出样例

输入 #1复制

70 3
71 100
69 1
1 2

输出 #1复制

3

说明/提示

【数据范围】

• 对于 30% 的数据，M≤10；
• 对于全部的数据，M≤100。

#include
int max[100010],time[1010],w[1010];
int main()
{
	int t,m,i,j;
	scanf("%d %d",&t,&m);
	for(i=1;i<=m;i++)
		scanf("%d %d",&time[i],&w[i]);
	for(i=1;i<=m;i++)
        for(j=t;j>=0;j--)//倒序哦，不然会重复 
            if(j>=time[i])//可以选择
                max[j]=max[j]>(max[j-time[i]]+w[i])?max[j]:(max[j-time[i]]+w[i]);
	printf("%d\n",max[t]);
}