Acm3-栈、队列、及移位运算符

最新推荐文章于 2020-09-30 14:32:18 发布
最新推荐文章于 2020-09-30 14:32:18 发布
阅读量382 收藏
点赞数
分类专栏： Acm
版权声明：本文为博主原创文章，遵循 CC 4.0 BY 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/dally2/article/details/78419957
版权

微笑重点：栈、队列、及移位运算符

栈和队列

1.栈：

特点:FILO；

用处：常用与括号匹配；火车进站出站的顺序排列，发生的可能性；

<1>顺序栈：        

#include<iostream>
#include<cstdio>
#include<string>
#include<cstring>
#include<cstdlib>
#define INI 1000
#define INC 1000
#define OK 1
#define ERROR 0
#define TRUE 1
#define OVERFLOW -2
using namespace std;
struct Stack
{
    int* top;
    int* base;
    int Size;
}s;
int Init(Stack& S)
{
	S.base=(int *)malloc(INI*sizeof(int));
	if(!S.base) exit(OVERFLOW);
	S.top=S.base;
	S.Size=INI; 
	return OK;
}
int Push(Stack& S,int e)
{
	if(S.top-S.base>=S.Size)
	{
		S.base=(int *)realloc(S.base,(INC+S.Size)*sizeof(int));
		if(!S.base) exit(OVERFLOW);
		S.top=S.base+S.Size;
		S.Size=S.Size+INC;
	}
	*(S.top++)=e;
	return OK;
}
int Pop(Stack& S,int& e)
{
	if(S.top==S.base)
	return ERROR;
	e=*--S.top;
	return OK; 
}
int Gettop(Stack S,int &e)
{
	if(S.top==S.base) return ERROR;
	e=*--S.top;
	return OK;
}
int display(Stack S)
{
	while(S.base<S.top)
	{
	  cout<<*(--S.top)<<" ";	
	}
	cout<<endl;
	return OK;
}
int isEmpty(Stack S)
{
	if(S.top==S.base) return TRUE;
	return ERROR;
}
int Length(Stack S)
{
	return S.top-S.base;
}
int Clear(Stack& S)
{
	if(S.base)
	S.top=S.base; 
	return OK;
}
int Destory(Stack& S)
{
     if(S.base)	
     {
     	free(S.base);
     	S.base=S.top=NULL;
	S.Size=0; 
     }
	 return OK;
} 
 int main(){
	Stack S; 
	int N,e; 
	cout<<"1.构造一个空顺序栈"<<endl; 
	cout<<"2.链栈的入栈 "<<endl; 
	cout<<"3.链栈的出栈"<<endl; 
	cout<<"4.取栈顶元素"<<endl; 
	cout<<"5.判断是否为空栈"<<endl;
	cout<<"6.栈的长度"<<endl;
	cout<<"7.清除栈"<<endl;
	cout<<"8.销毁栈"<<endl; 
	cout<<"9.打印"<<endl; 
	while(1){
		cout<<"输入操作数，输入负数结束"<<endl; 
		cin>>N;
		if(N==1)
		{
			if(Init(S)==OK)cout<<"构造空栈成功 "<<endl;	
		}
		else if(N==2)
		{
		   int cnt1=0,cnt=0;	
		   cout<<"输入入栈元素(0结束)"<<endl; 
		   while(true)
		   {
			cin>>e;
			if(e==0) break;
			cnt1++;
			if(Push(S,e)==OK)cnt++; 
		   }
		   if(cnt1==cnt) cout<<"入栈成功"<<endl; 
		}
		else if(N==3)
		{

			if(Pop(S,e)==OK) 
			cout<<"栈顶元素："<<e<<"  出栈成功"<<endl;
		}
		else if(N==4)
		{
			if(Gettop(S,e))
			cout<<"栈顶元素是"<<e<<endl;
			else
			cout<<"栈已空"<<endl;	
		}
		else if(N==5)
		{
			if(isEmpty(S))
			cout<<"栈为空"<<endl;
			else
			cout<<"栈不为空"<<endl; 
		}
		else if(N==6)
		{
			cout<<"该栈的长度是:"<<Length(S)<<endl;
		}
		else if(N==7)
		{
			if(Clear(S))
			cout<<"成功清除"<<endl;
		}
		else if(N==8)
		{
			if(Destory(S))
			cout<<"成功销毁"<<endl; 
		}
		else if(N==9)
		{
			 display(S);
		}	
		else if(N<=-1)
		{
			exit(0);
		}
		else
		{
			cout<<"请输入正确的序号"<<endl;
		}
	
		
	}	
	return 0;
}
<2>链栈
 
#include<iostream>
#include<cstring>
#include<string>
#include<cstdlib> 
using namespace std;
#define INI 1000
#define INC 1000
#define NULL 0
#define OK 1
#define ERROR 0
#define TRUE 1
#define OVERFLOW -2 
struct Stack
{
	int data;
	Stack* next;
};
int Init(Stack*& S)
{
	S=NULL;
	return OK;
}
int Push(Stack*& S,int e)
{
	Stack* p=(Stack*)malloc(sizeof(Stack));
	if(!p) exit(OVERFLOW);
	p->data=e;
	p->next=S;
	S=p;
	return OK;
}
int Pop(Stack*& S,int& e)
{
	Stack* p=(Stack*)malloc(sizeof(Stack));
	
	p=S;
	if(p==NULL) return ERROR;
	e=p->data;
	S=S->next;
	free(p);
	return OK; 
}
int Gettop(Stack* S,int &e)
{
	e=S->data; 
	return OK;
}
int display(Stack* S)
{
	while(S!=NULL)
	{
		cout<<S->data<<" ";
		S=S->next;
	}
	return OK;
}
int isEmpty(Stack* S)
{
	if(S==NULL) return TRUE;
	return ERROR;
}
int Length(Stack* S)
{
	int n=0;
	while(S!=NULL)
	{
		S=S->next;
		++n; 
	}
	return n;
}
int Clear(Stack*& S)
{
	if(S!=NULL)
	 {
	 	S=NULL;
	 }
	return OK;
}
int Destory(Stack*& S)
{
     while(S!=NULL)	
     {
     	free(S);
     	S=S->next;
      }
	 return OK;
} 
 int main(){
	Stack* S;
	int N,e; 
	cout<<"1.构造一个空顺序栈"<<endl; 
	cout<<"2.链栈的入栈 "<<endl; 
	cout<<"3.链栈的出栈"<<endl; 
	cout<<"4.取栈顶元素"<<endl; 
	cout<<"5.判断是否为空栈"<<endl;
	cout<<"6.栈的长度"<<endl;
	cout<<"7.清除栈"<<endl;
	cout<<"8.销毁栈"<<endl; 
	cout<<"9.打印"<<endl; 
	while(1){
		cout<<"输入操作数，输入负数结束"<<endl; 
		cin>>N;
		if(N==1)
		{
			if(Init(S)==OK)cout<<"构造空栈成功 "<<endl;	
		}
		else if(N==2)
		{
		   int cnt1=0,cnt=0;	
		   cout<<"输入入栈元素(0结束)"<<endl; 
		   while(true)
		   {
			cin>>e;
			if(e==0) break;
			cnt1++;
			if(Push(S,e)==OK)cnt++; 
		   }
		   if(cnt1==cnt) cout<<"入栈成功"<<endl; 
		}
		else if(N==3)
		{

			if(Pop(S,e)==OK) 
			cout<<"栈顶元素："<<e<<"  出栈成功"<<endl;
			else
			cout<<"栈已空"<<endl; 
		}
		else if(N==4)
		{
			if(Gettop(S,e))
			cout<<"栈顶元素是"<<e<<endl;
			else
			cout<<"栈已空"<<endl;	
		}
		else if(N==5)
		{
			if(isEmpty(S))
			cout<<"栈为空"<<endl;
			else
			cout<<"栈不为空"<<endl; 
		}
		else if(N==6)
		{
			cout<<"该栈的长度是:"<<Length(S)<<endl;
		}
		else if(N==7)
		{
			if(Clear(S))
			cout<<"成功清除"<<endl;
		}
		else if(N==8)
		{
			if(Destory(S))
			cout<<"成功销毁"<<endl; 
		}
		else if(N==9)
		{
			 display(S);
		}	
		else if(N<=-1)
		{
			exit(0);
		}
		else
		{
			cout<<"请输入正确的序号"<<endl;
		}
	}	
	return 0;
}


2.队列：

特点：FIFO；(表前删除，表后添加)

形式：

1).方法一:顺序队列

#include<iostream>
#include<cstring>
#include<algorithm>
#define OK 1
#define ERROR 0
#define TRUE 1
#define OVERFLOW -2
#define maxSize 10
using namespace std;
struct Queue
{
    int *elem;
    int rear;
    int front;
};
int Init(Queue& Q)
{
	Q.elem=(int*)malloc(maxSize*sizeof(int));
	if(!Q.elem) exit(OVERFLOW);
	Q.rear=Q.front=0;
	return OK;
}
int EnQueue(Queue& Q,int e)
{
    if((Q.rear+1)%maxSize==Q.front) 
	return ERROR;
    Q.elem[Q.rear]=e;
    Q.rear=(Q.rear+1)%maxSize;
	return OK;	
} 
int DeQueue(Queue& Q,int& e)
{
    if(Q.rear==Q.front) return ERROR;
    e=Q.elem[Q.front];
    Q.front=(Q.front+1)%maxSize;
    return OK;
} 
int isEmpty(Queue Q)
{
	cout<<"Q.rear:"<<Q.rear<<" Q.front:"<<Q.front<<endl;
	return !Q.rear-Q.front;
}
int Leng(Queue Q)
{
	int len=(maxSize+Q.rear-Q.front)%maxSize;
	return len;	
} 
int Traverse(Queue Q)
{
	if(!Q.elem||Q.front==Q.rear)
	return ERROR;
	while(Q.front!=Q.rear) 
	{
	    cout<<Q.elem[Q.front]<<" ";
	    Q.front=(Q.front+1)%maxSize;
	} 
	cout<<endl;
	return OK;
} 
int Clear(Queue& Q)
{
	if(Q.front)
	{
		Q.rear=Q.front;
	}
	return OK;
}
int Destory(Queue& Q)
{
	if(Q.elem)
	{
		free(Q.elem);
	}
	return OK;
}
int main()
{
	Queue Q;
	int e,n;
	Init(Q);
	cout<<"1.入队"<<endl;
	cout<<"2.出队"<<endl;
	cout<<"3.队长度"<<endl;
	cout<<"4.队是否为空"<<endl;
	cout<<"5.队的清除"<<endl;
	cout<<"6.队的销毁"<<endl;
	cout<<"7.队的遍历"<<endl; 
	while(true)
	{
	  cout<<"输入你的选项:"<<endl;
	  cin>>n;
	  switch(n)
	  {
	  case 1:
	  	{
	  	 int cnt=0,cnt1=0;
	  	 cout<<"输入正整数（0结束）:"<<endl; 
	  	 while(true)
	  	 {
	  	 cin>>e;
	  	 if(!e) break;
		 cnt++;	
	  	 if(EnQueue(Q,e))
	  	 cnt1++;
	     }
	     cout<<"入队成功!"<<endl;
		} break;
	  case 2:
	  	{
	  	  if(DeQueue(Q,e))
			cout<<"出队元素为:"<<e<<endl; 
		  else
		    cout<<"队为空！"<<endl; 
		}break;
	  case 3:
	  	{
	  	  cout<<"队长度为:"<<Leng(Q)<<endl;	
		} break;
	  case 4:
	  	{
	  	  if(isEmpty(Q))
			cout<<"队列为空！"<<endl;
		  else
		    cout<<"队列不为空！"<<endl;	
		} break;
	  case 5:
	  	{
	  		if(Clear(Q))
			  cout<<"队清除成功！"<<endl;
			else
			  cout<<"抱歉，没有成功！"<<endl; 
		}  break;
	  case 6:
	  	{
	  	   if(Destory(Q))	
	  	   cout<<"销毁成功！"<<endl;
		   else
		   cout<<"操作失败！"<<endl; 
		}
	  break;
	  case 7:
	  	{
	  	    if(!Traverse(Q))
			  {
			  cout<<"队列为空！"<<endl;	
			  }	
		}
	  break;
	  default:
	  break;	
	  }	
	}
}

2).方法二：链队列

#include<iostream>
#include<cstring>
#include<string>
#include<cstdio>
#include<cstdlib>
#include<algorithm>
#define OK 1
#define ERROR 0
#define TRUE 1
#define OVERFLOW -2
using namespace std;
typedef struct node
{
   int data;
   struct node* next;	
}node,*link;
struct Queue
{
	node* rear;
	node* front;
};
int Init(Queue& Q)
{
	Q.rear=Q.front=(link)malloc(sizeof(node));
	if(!Q.front) exit(OVERFLOW);
	Q.front->next=NULL;
	return OK;
}
int EnQueue(Queue& Q,int e)
{
        link p=(link)malloc(sizeof(node));
	if(!p) exit(OVERFLOW);
	p->data=e;
	p->next=NULL;
	Q.rear->next=p;
	Q.rear=p;
	return OK;	
} 
int DeQueue(Queue& Q,int& e)
{
    if(Q.rear==Q.front) return ERROR;
    link p=(link)malloc(sizeof(node));
    p=Q.front->next;
    e=p->data;
    Q.front->next=p->next;
    if(p==Q.rear) Q.rear=Q.front;
    free(p);
    return OK;
} 
int isEmpty(Queue Q)
{
	return Q.rear-Q.front;
}
int Leng(Queue Q)
{
        int n=0;
	while(Q.front!=Q.rear)
	{
	  Q.front=Q.front->next;
	  ++n; 
	} 
	return n;	
} 
int Traverse(Queue Q)
{
	while(Q.front!=Q.rear) 
	{
		cout<<Q.front->next->data<<" ";
		Q.front=Q.front->next; 
	} 
	cout<<endl;
	return OK;
} 
int Clear(Queue& Q)
{
	if(Q.front)
	{
		Q.rear=Q.front;
	}
	return OK;
}
int Destory(Queue& Q)
{
	while(Q.front)
	{
		Q.rear=Q.front->next;
		free(Q.front);
		Q.front=Q.rear;
	}
	return OK;
}
int main()
{
	Queue Q;
	int e,n;
	Init(Q);
	cout<<"1.入队"<<endl;
	cout<<"2.出队"<<endl;
	cout<<"3.队长度"<<endl;
	cout<<"4.队是否为空"<<endl;
	cout<<"5.队的清除"<<endl;
	cout<<"6.队的销毁"<<endl;
	cout<<"7.队的遍历"<<endl; 
	while(true)
	{
	  cout<<"输入你的选项:"<<endl;
	  cin>>n;
	  switch(n)
	  {
	  case 1:
	  	{
	  	 int cnt=0,cnt1=0;
	  	 cout<<"输入正整数（0结束）:"<<endl; 
	  	 while(true)
	  	 {
	  	 cin>>e;
	  	 if(!e) break;
		 cnt++;	
	  	 if(EnQueue(Q,e))
	  	 cnt1++;
	     }
	     cout<<"入队成功!"<<endl;
		} break;
	  case 2:
	  	{
	  	  if(DeQueue(Q,e))
			cout<<"出队元素为:"<<e<<endl; 
		  else
		    cout<<"队为空！"<<endl; 
		}break;
	  case 3:
	  	{
	  	  cout<<"队长度为:"<<Leng(Q)<<endl;	
		} break;
	  case 4:
	  	{
	  	  if(isEmpty(Q))
			cout<<"队列为空！"<<endl;
		  else
		    cout<<"队列不为空！"<<endl;	
		} break;
	  case 5:
	  	{
	  		if(Clear(Q))
			  cout<<"队清除成功！"<<endl;
			else
			  cout<<"抱歉，没有成功！"<<endl; 
		}  break;
	  case 6:
	  	{
	  	   if(Destory(Q))	
	  	   cout<<"销毁成功！"<<endl;
		   else
		   cout<<"操作失败！"<<endl; 
		}
	  break;
	  case 7:
	  	{
	  	    if(!Traverse(Q))
			  {
			  cout<<"队列为空！"<<endl;	
			  }	
		}
	  break;
	  default:
	  break;	
	  }	
	}
}


3).方法三:STL库

#include<queue>

using namespacestd;

queue<int>Q;

入列：Q.push(入列元素);

出列：Q.pop();

栈and队列在STL使用：

1、栈

加上“stack”的头文件，常用的函数有：

stack<int>p; 

p.push（）；p.pop（）；p.top（）；p.size（）；p.empty（）；

2、队列

加上<queue>的头文件，常用的函数有：

queue<int>q;

p.push（）；p.pop（）；q.front（）；q.back（）；p.size（）；p.empty（）；

队列中有个特殊的地方，优先队列priority_queue;

priority_queue<int>q;

自定义优先级：

struct  cmp

{

   operator bool ()(int x, int y)

   {

       return　x > y; // x小的优先级高

     //也可以写成其他方式，如： return p[x] > p[y];表示p[i]小的优先级高

}

};

priority_queue<int,vector<int>, cmp>q;//定义方法

结构体的优先级定义：

structnode

{

   int x, y;

   friend bool operator < (node a, node b)

   {

       return a.x > b.x; //结构体中，x小的优先级高

   }

};

priority_queue<node>q;//定义方法

3.移位运算符

可分为两种：

1).与符号无关

形如：<<<(向左运算符)和>>>(向右运算符);

2).与符号有关

形如：<<(向左运算符)和>>(向右运算符);

a.<<向左运算符

8<<1(符号为正)：表示二进制的数向左移动1位；

      8的二进制是：00001000向左移动1位->变为00010000(想象一下动态的小链条向左移动，最后在最右边补0);

-8<<1(符号为负):我们易得-8的二进制是:10001000->向左移动1位->10010000(符号位不变，在最右边补0);

b.>>向右运算符

 8>>1(符号为正)：表示二进制的数向右移动1位；

      8的二进制是：00001000向右移动1位->变为00000100(想象一下动态的小链条向右移动，最后在最左边补0);

-8>>1(符号为负):我们易得-8的二进制是:10001000->向右移动1位->11000100(符号位不变，在最左边补1);     

Dymc
关注
专栏目录
个人ACM-ICPC模板acm-icpc-master.zip
02-05
2. **数据结构**：如链表、队列、栈、树、图、哈希表、优先队列（堆）等的实现，这些在ACM-ICPC中非常常见。 3. **算法实现**：包括排序算法（快速排序、归并排序、堆排序等）、搜索算法（深度优先搜索、广度优先...
【C语言】利用队列的思维理解移位运算符和移位函数
m0_72963799的博客
10-14 5187
在c语言中，尤其是单片机的C51中，移位运算操作很常见。实现移位操作的方法有两种：一是利用移位运算符，二是利用移位函数。移位运算符，是系统内置的运算操作，编译编译不用包含相关头文件；而移位函数编译要包含intrins.h头文件。移位运算符操作，移除位后舍弃，循环移位函数移出位后不舍弃，而是从另一端补位进来。
栈来实现队列，不借用第三变量交换数据，数值移位运算
指尖岁月，“码”的人生
10-06 1000
一、用两个栈来实现队列的功能       一开始我的思路是：当存取时向一个栈中进行Push操作，当取时将存入数据的栈进行Pop操作，然后放入第二个栈中，将最后一个取出，然后再放回原来的栈。      这是考官说要我改进我的思想，因为我的操作浪费时间，来回的在两个栈进行数据操作：这是你就很好想到改进，呢就是当将压栈数据放到第二个栈之后，没必要在放回去，直接取第二个栈就可以了，存还是存第一个栈内。
循环队列，可变长队列（缓冲）及优化
wedy542700927的专栏
08-17 4324
写在前面写这篇博客的灵感来自于自己在项目上用到的循环队列，顺便讲讲libevent中evbuffer和muduo（木铎）中buffer。循环队列循环队列是很常见的数据结构，在大学计算机课程上也会遇到，被应用到很多场景，比如管道的实现（固定的容量64K）、MapReduce中数据溢写入磁盘（默认100M，超过80M溢写）、网络库中常见的IO buffer等等。 循环队列需要两个索引head和tail
位运算
weixin_30823683的博客
01-29 192
运算方法有六种： & 与运算 | 或运算 ^ 异或运算 ~ 非运算(求补) >> 右移运算 << 左移运算 运用这些基本的运算，我们可以解决acm所需的各种运算,给Bit赋1，赋0，给他的值取反，还有好多段操作。如下： 功能 | 示例 | 位运算----------------------+---------------------------+...
[字符串] 一个巧妙的字符串循环移位法
童凌的技术博客
07-16 5612
给定一个长度为m的串，将其循环移位，向右移动n位，输出循环移位后的字符串： 例: m=7,n=3; 移动前：”1234567” 移动后：”5671234”一个巧妙的办法： 将给定的串分割成两个串，长度分别为m-n和n，分别将其翻转，翻转后将其连接成一个串，再次翻转，就得到了最终移动后的串！“1234567” “1234”,”567” “4321”,”765” “4321765” “
基于C++的ACM-ICPC模板
02-22
3. **基础工具函数**：提供一些常用的数据结构（如栈、队列、链表、树、图等）和算法（排序、搜索、数学运算等）的实现，方便调用。 4. **模板类**：定义了一些常用的模板类，如大整数操作、矩阵运算、动态规划状态...
ACM题集-ACM训练题集-超多ACM题集汇总-解题源码
最新发布
01-17
2. **数据结构**：链表、数组、栈、队列、堆、树（二叉树、平衡树如AVL和红黑树）、图（邻接矩阵、邻接表等）以及跳跃表等。 3. **图论**：深度优先搜索（DFS）、广度优先搜索（BFS）、最短路径算法（Dijkstra、...
ACMICPC-Latex模板：一个简单的ACM-ICPC（LaTeX）模板生成器
02-04
一个简单的ACM-ICPC模板生成器 一个非常简单的ACM-ICPC代码模板生成工具。 从源代码目录生成模板而无需将其复制到docx或tex文件，仅需执行一条命令。 您只需要做的就是使用python gen.py生成模板PDF文件。 要求 ...
ACM-PAT甲级题目总结及实现
03-24
2. **数据结构**：链表、栈、队列、树、图等经典数据结构的运用。例如，二叉树的遍历、最小生成树、拓扑排序等。 3. **动态规划**：动态规划方法常用于解决最优化问题，如背包问题、最长公共子序列、矩阵链乘等。...
ACM训练总结（栈与队列）
weixin_45664948的博客
04-05 193
又过了一个星期，距离回学校又近了一步。 这周学习了两种数据结构，栈和队列。 栈是一种只能在一端插入或者删除的线性表。 1．进栈（PUSH）算法 ①若TOP≥n时，则给出溢出信息，作出错处理（进栈前首先检查栈是否已满，满则溢出；不满则作②）； ②置TOP=TOP+1（栈指针加1，指向进栈地址）； ③S(TOP)=X，结束（X为新进栈的元素）； 2．退栈（POP）算法 ①若TOP≤0...
数组循环移位算法
我的梦
12-12 7056
题记：不要多想，好好敲代码，看书，就这样，加油。 昨天在看博客的时候，发现一个有意思的算法，但是原博客代码不全，自己就在它的基础上，按自己的理解把循环左移、循环右移的算法写出来了 优点是动态建立数字，较好 原博客：http://blog.csdn.net/ns_code/article/details/8846643 该种算法可能对循环队列缓冲移位有一定的帮助，特和大家分享： 循环左移算
python的移位操作
python学习者的博客
09-30 3068
因为要将js的一个签名算法移植到python上，遇到一些麻烦。 int无限宽度，不会溢出 算法中需要用到了32位int的溢出来参与运算，但是python的int是不会溢出的，达到界限后会自己转为long，所以很麻烦。 #使用-342686650: ret = 123456789 << 20 print(ret) 得到结果129453825982464 print(bin(ret)) 这个二进制是11101011011110011010001010100000000000000000000 明显已
顺序表应用3：元素位置互换之移位算法
xxxchic
10-02 1353
顺序表应用3：元素位置互换之移位算法 Time Limit: 1000MS Memory limit: 570K 题目描述 一个长度为len(1数据元素的类型为整型，将该表分成两半，前一半有m个元素，后一半有len-m个元素（1 注意：先将顺序表元素调整为符合要求的内容后，再做输出，输出过程只能用一个循环语句实现，不能分成两个部分。 输入  第一
队列实现对有n个元素的数组循环左移k位
杨哥的专栏
03-28 3577
基本思想：利用队列求解将使问题简单化，将数组的0-（k-1）存入队列，然后将数组k-（n-1）依次左移k位，然后顺序出列，具体算法如下： #include #include #define MAXSIZE 100 typedef struct { int data[MAXSIZE]; int front,rear; }SeqQueue,*PSeqQueue; PSeqQueue Init_
acm3
weixin_45714652的博客
03-22 266
初学动态规划 知识部分 (1) 最优化原理：如果问题的最优解所包含的子问题的解也是最优的，就称该问题具有最优子结构，即满足最优化原理。 (2) 无后效性：即某阶段状态一旦确定，就不受这个状态以后决策的影响。也就是说，某状态以后的过程不会影响以前的状态，只与当前状态有关。 初始状态→│决策１│→│决策２│→…→│决策ｎ│→结束状态 图1 动态规划决策过...
位运算应用口诀和实例
llxwj的专栏
04-02 1026
 位运算应用口诀 清零取反要用与，某位置一可用或若要取反和交换，轻轻松松用异或移位运算要点 1 它们都是双目运算符，两个运算分量都是整形，结果也是整形。     2 "     3 ">>"右移：右边的位被挤掉。对于左边移出的空位，如果是正数则空位补0，若为负数，可能补0或补1，这取决于所用的计算机系统。     4 ">>>"运算符，右边的位被挤掉，对于左边移出的
数据结构与算法（六）—— 队列及其实现和应用
小羽毛的博客
12-30 2569
注：本篇内容参考了《Java常用算法手册》、《大话数据结构》和《Java编程（第四版）》三本书籍，并参考了在线工具网站中对于队列相关Java类的一些说明。 文中涉及的java以Java 1.8为准。 本人水平有限，文中如有错误或其它不妥之处，欢迎大家指正！ 目录 1. 队列 1.1 队列定义 1.2队列的特点 1.3队列的分类 1.4. 队列的操作 1.4.1 入队列 ...
acm入门——栈与队列
qq_43546060的博客
07-29 197
参考：关于栈与队列 例题一： 愚人节的礼物 代码： #include<iostream> #include<cstring> #include<stack> using namespace std; stack<int> s; //定义一个int类型的栈 int main() { char a[1001]; int i=0; whi...
ACM竞赛必备：栈队列算法与数据结构解析
"本文主要介绍了在ACM竞赛中常用的算法和数据结构，特别是栈和队列，以及如何构建一支强大的竞赛队伍。同时提到了一些重要的参考书籍和常见题型，并简单介绍了枚举法。" 在ACM竞赛中，数据结构和算法是至关重要的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值