6-1 并行程序模拟 uva210 队列（双端队列)
#include<cstdio>
#include<queue> //队列容器
#include<cstring>
#include<cstdlib>
#include<cctype> //定义了有关字符判断和处理的库函数
using namespace std;
const int maxn = 1000;
deque<int> readyQ;
queue<int> blockQ;
int n,quantum,c[5],var[26],ip[maxn];//n为程序数，quantum为每次最多运行时间，c[5]中存储5总语句需要执行的时间
//var[26]代表26个字母变量对应的值
bool locked; //标识是否锁
char prog[maxn][10];//存储第maxn个程序对应的语句
void run(int pid){
int q = quantum;
while(q > 0){
char *p = prog[ip[pid]]; //ip[pid]是程序pid的当前行号。所有的程序都存在prog数组 获得pid程序的第ip[pid]语句
switch(p[2]){//判断是哪条语句
case '=' :
var[p[0] - 'a'] = isdigit(p[5]) ? (p[4] - '0') * 10 + p[5] - '0' : p[4] - '0'; //变量对应的值不超过100，需要判断否有十位
q -= c[0] ; //最多执行时间-已赋值语句执行时间
break;
case 'i' : //print var
printf("%d: %d\n",pid+1, var[p[6] - 'a']); //p[6] 代表输出的变量; var[ p[6] - 'a']代表这个变量对应的值
q -= c[1];
break;
case 'c': //lock
if(locked){ //如果之前已锁则加入堵塞队列
blockQ.push(pid); return;//加入阻塞队列后，退出循环，则未解锁之前这个程序中的语句不再执行
}
locked = true;
q -= c[2] ;
break;
case 'l': //unlock
locked = false;
if(!blockQ.empty()){ //当unlock执行完毕后，阻止队列的第一个程序进入等待队列的首部
int pid2 = blockQ.front();
blockQ.pop();
readyQ.push_front(pid2);
}
q -= c[3] ;
break;
case 'd': //end
return;
}
ip[pid]++; //此时ip[pid]为程序pid中未执行语句的第一行
}
readyQ.push_back(pid); //一条语句结束后，判断此次时间片是否用完，如用完则该程序pid退出，否则继续执行程序pid的下一条语句
}
int main(){
int T; //cases数
scanf("%d",&T);
while(T--){
scanf("%d %d %d %d %d %d %d",&n,&c[0],&c[1],&c[2],&c[3],&c[4],&quantum);
memset(var,0,sizeof(var));
int line = 0;
for(int i = 0; i < n; i++){ //存储所有程序的语句到prog,ip[i]记录程序i的第一条语句所在位置
fgets(prog[line++],maxn,stdin); //从指定的流中每次读取一行，存储在prog[line]数组中，maxn指最大字符1024
ip[i] = line - 1; //程序i的第一条语句所在位置
while(prog[line - 1][2] != 'd')//prog为二维数组 存储语句 因为语句的第三为是确定的，故判断第三位，如果是d则表示是end 结束输入
fgets(prog[line++],maxn,stdin);
readyQ.push_back(i); //存储完语句，准备工作完成，将程序加入准备队列
}
locked = false;
while(!readyQ.empty()) {
int pid = readyQ.front(); //获得准备队列队首程序
readyQ.pop_front(); //出队
run(pid); //执行程序
}
if(T) printf("\n");
}
return 0;
}
6-2 铁轨 uva514 栈
#include<cstdio>
#include<stack>
using namespace std;
const int MAXN = 1010;
int n,target[MAXN];
int main() {
while(scanf("%d",&n) && n) { //定义输入格式 如果输入的非0 则继续
for(;;) { //不知道输入数据有多少个
stack<int> s; //初始化栈s
int A = 1, B = 1;
//每组输入数据第一个为0时结束输入
scanf("%d",&target[1]);
if(target[1] == 0) {
printf("\n"); //注意输入为0时需要空行
break; //跳出for循环
}
for(int i = 2; i <= n; i++) { //从1开始
scanf("%d", &target[i]);
}
int ok = 1;
while(B <= n) {
if(A == target[B]) {
A++;
B++;
} else if(!s.empty() && s.top() == target[B]) {
s.pop();
B++;
} else if(A <=n) s.push(A++);
else {
ok = 0;
break;
}
}
printf("%s\n",ok ? "Yes" : "No");
}
}
return 0;
}
6-3 矩阵链乘 uva442 栈
#include<cstdio>
#include<stack>
#include<iostream>
#include<string>
using namespace std;
//由Expression = Matrix | "(" Expression Expression ")"可以得到左括号和右括号是相匹配的，并且括号对数比矩阵数多一
//故可以遇到左括号忽略，遇到矩阵入栈，遇到右括号出栈。 如果格式定义为AB则错误
struct Matrix {
int a,b; //成员变量
Matrix(int a = 0, int b = 0) : a(a),b(b){} //构造函数 先将a和b初始化为0，若主函数里的调用函数中参数a和b不为零，则a=a,b=b;
} m[26]; //m[26] 结构体数组
stack<Matrix> s;
int main(){
int n;
cin >> n;
for(int i = 0; i < n; i++){
string name;
cin >> name;
int k = name[0] - 'A'; //string 类型（name)没有减号运算符，字符类型有！
cin >> m[k].a >> m[k].b;
}
string expr;
while(cin >> expr){
int len = expr.length();
bool error = false;
int ans = 0;
for(int i = 0; i < len; i++){
if(isalpha(expr[i])) s.push(m[expr[i] - 'A']);
else if(expr[i] == ')'){
Matrix m2 = s.top(); s.pop();
Matrix m1 = s.top(); s.pop();
if(m1.b != m2.a) { error = true; break;
}else{
ans += m1.a * m1.b * m2.b;
s.push(Matrix(m1.a,m2.b));
}
}
}
if(error) printf("error\n"); else printf("%d\n",ans);
}
return 0;
}
6-4 破损的键盘 uva11988 不太懂，需要回顾
链表 有指针域和数据域
也可用两个数组替代指针：next数组表示结点的地址，data数组表示数据的地址 ||||| next[0]中存储的值是下一个结点的地址，同时也是本个结点的数据地址（另一个数组存储数据）
#include<cstdio>
#include<cstring>
const int maxn = 100000 + 5;
int last, cur, next[maxn]; //光标位于cur字符之后
char s[maxn] ;
/*
采用链表
将输入的每个字符都存到字符串列表s[1~n]
用next[i]表示当前显示屏中s[i]右边的字符编号（即在s中的下标）
next[0~n-1] next[0]表示s[1]
cur表示光标位置 cur=1表示当前光标在s[1]的右边 cur=0表示当前光标在 虚拟字符s[0]右边
*/
s[next[i]] s[next[next[i]]] s[next[next[next[i]]]]
int main(){
while(scanf("%s",s+1) == 1) { //从s[1]开始存储字符
int n = strlen(s+1) ; //输入保存在s[1],s[2]...中
last = cur = 0;
next[0] = 0;
for(int i = 1; i <= n;i++){
char ch = s[i];
if(ch == '[') cur = 0;
else if(ch == ']') cur = last;
else{
next[i] = next[cur];
next[cur] = i; //next中存储光标位置
if(cur == last) last = i;//一般来说当前光标和最后光标相同，如果cur移动到首部，则最后光标位置不变
cur = i; //移动光标
}
}
for(int i = next[0]; i != 0; i = next[i])
printf("%c",s[i]);
printf("\n");
}
return 0;
}6-6 小球下落 uva679 二叉树结点状态的改变
分析：由题意知该二叉树为满二叉树（所有结点从上到下从左到右编号为1、2、3....2^D-1)。每个结点初始状态为关闭。有很多个小球，小球在某结点处如果结点状态为关闭，往左下走，同时改变结点状态，否则往右下走，同时改变结点状态。问有D层二叉树，第i个小球会落到哪个叶子结点。
思路：
初始化结点状态数组为0，
for循环让i个小球下落，每次下落需先改变当前结点状态在下落（如果先下落再改变之前的结点状态的话会比较麻烦），直到下落的结点出界。
最后一次循环下落的值即为所求的叶子编号。
#include<cstdio>
#include<cstring>
const int maxd = 20;//D<=20
int s[1<<maxd]; //最大结点数为2^maxd - 1
int main() {
int l;
while(scanf("%d",&l) && l!= -1) {
for(int j = 0; j < l; j++) {
int D,I; //叶子深度D，小球个数I
scanf("%d %d",&D,&I);
int k,n = (1 << D) - 1; //叶子结点数
int leaf = 1 << (D-1);
memset(s,0,sizeof(s));//初始全部关闭
for(int i = 0; i < I; i ++) { //连续让i个小球下落
k = 1; //每次从根结点开始下落
for(;;) {
s[k] = !s[k]; //改变结点状态
k = s[k] ? k*2:k*2+1 ;//s[k]=0,往右走。s[k]=1,往左走。因为此时的s[k]是改变状态之后的
if(k>n) break; //这样判断更具有一般性
}
}
printf("%d\n",k/2); //“出界”之前的叶子编号
}
}
return 0;
}但是！！！这样的实现有个很大的缺点，运算量太大。提交后会出现超时提醒。
改进：每个小球都会落在根节点上，因此前两个小球必然是一个左子树，一个在右子树。一般地，只需看小球编号的奇偶性，就能知道它最终在哪颗子树中，对于拿些落入根结点左子树的小球来说，只需知道该小球是第几个落在根的左子树里的，就可以知道它下一步往左还是往右。以此类推，直到小球落到叶子上。
如果使用题目中给出的编号I，则当I是奇数时，它是往左走的第(I+1)/2个小球，如果I是偶数，它是往右走的第I/2个小球。这样可以直接模拟最后一个小球的路线。
I是奇数往左走是因为初始结点是关闭的，要改变结点状态然后往左子结点走。
I是偶数时结点状态是开的，要改变结点状态然后往右子结点走。
然后每个结点都可看作是根结点。
#include<cstdio>
#include<cstring>
int main(){
int l;
while(scanf("%d",&l) && l!=-1){
for(int i = 0; i < l; i++){
int D,I;
scanf("%d %d",&D,&I);
int k = 1;
for(int i=1; i < D;i++){ //模拟最后一个小球路线 到D-1层即可
if(I%2){ k = k*2; I = (I+1)/2;} //I%2的可能值0、1
else {k = k*2+1;I/=2;}
}
printf("%d\n",k);
}
}
return 0;
}
6-7 二叉树的层次遍历 uva122 构造树，bfs,添加结点
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<vector>
#include<queue>
using namespace std;
const int maxn = 256 + 10;
//定义结点结构
struct Node{
bool have_value;//是否有值 （因为由结点构造树是不按顺序的，有可能从根到某个叶结点的路径上有的结点没有在输入中给出，或者给出超过了一次）
int v; //保存结点的值
Node* left,*right;//左右子结点
//结构体的构造函数
Node():have_value(false),left(NULL),right(NULL){}
};
Node* root; //根结点
//申请新结点
Node* newnode(){
return new Node();
}
//添加新结点
bool failed;
void addnode(int v,char *s){
int n = strlen(s);
Node* u = root;//指向根结点的指针
for(int i = 0; i < n; i++){
if(s[i] == 'L'){
if(u -> left == NULL) u->left = newnode();
u = u->left;
}else if(s[i] == 'R'){
if(u -> right == NULL) u->right = newnode();
u = u->right;
}
}
if(u->have_value) failed = true; //如果此结点之前已有值则创建结点失败
u->v = v;
u->have_value = true;
}
//释放二叉树 清内存
void remove_tree(Node* u){
if(u == NULL) return;
remove_tree(u->left);
remove_tree(u->right);
delete u;
}
//读入
char s[maxn];
bool read_input(){
failed = false;
remove_tree(root); //创建树之前先清空
root = newnode(); //根结点
for(;;){
if(scanf("%s",s) != 1) return false;
if(!strcmp(s,"()")) break;
int v;
sscanf(&s[1],"%d",&v);
addnode(v,strchr(s,',') + 1);
}
return true;
}
//树的层次遍历 广度优先遍历
bool bfs(vector<int>& ans){
queue<Node*> q; //q队列存放结点
ans.clear();
q.push(root);
while(!q.empty()){
Node* u = q.front(); q.pop();
if(!u->have_value) return false;
ans.push_back(u->v); //记录本结点值
if(u->left != NULL) q.push(u->left);//左孩子结点入队
if(u->right != NULL) q.push(u->right); //右孩子结点入队
}
return true;
}
int main(){
vector<int> ans;
while(read_input()){
if(!bfs(ans)) failed = 1;
if(failed) printf("not complete\n");
else{
for(int i = 0; i < ans.size();i++){
if(i != 0) printf(" ");
printf("%d",ans[i]);
}
printf("\n");
}
}
return 0;
}
2790
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
