进站编程

⑴ VB优化编程问题

1.标志符名称
2.注释
3.空行
其他元素，如变量、窗体和过程，确实要占用内存的一部分空间，最好将它们精简以使效率更高。当应用程序作为一个.exe文件运行时，有几项技术可用于缩小应用程序所需内存。以下技术可缩小代码大小：
1.减小加载窗体数目
2.减小控件数目
3.用标签代替文本框
4.保持数据在磁盘文件和资源中，并且只在最需要时才加载
5.组织模块
6.考虑替换Variant数据类型
7.使用动态数组，并在删除时回收内存空间
8.消除死代码和无用的变量
9.回收被字符串和对象变量用过的空间
一、每一个加载的窗体，无论是与否，都要占用一定数量的内存（其数量随着窗体上控件的类型和数量，以及窗体上位图的大小等不同而有所改变）。所以，为了节约内存，我们只在需要时才加载窗体，不需要时卸载窗体（而不是隐藏窗体）。记住：任何对窗体的引用，和对用New声明的窗体变量的引用，都会导致VB加载该窗体。
当使用Unload方法卸载窗体时，只能卸载释放掉部分窗体所占的空间。若想释放所有空间，可用关键字Nothing使窗体的引用无效，如：Set From=Nothing
二、设计应用程序时，窗体应尽量少用控件。实际的限制取决于控件的类型和系统。实际上，含有大量控件的窗体将运行缓慢。一项与之相关的技术就是：在设计时，尽可能使用控件数组，而不是在窗体上放置大量同类型的控件。
三、标签控件占用的Windows资源比文本框少，因此，在可能的情况下，应使用标签代替文本框。通过适当设置BackColor和BorderStyle的属性，可以使标签看起来像文本框，虽说这会需要更多的代码，但对于含有大量文本域的窗体，它可以大大地减少资源的使用。

⑵ 用C++编程

#include<stdio.h>
#include<iostream>
#include<stack>
using namespace std;
int main()
{
bool islegal=true;
stack<char> a; //栈
char s[100];
gets(s);
for(int i=0;s[i];i++)
{
switch(s[i])
{
case '(':
case '[':
case '{': a.push(s[i]); break; //入栈
case ')': if(a.top()!='(') {islegal = false ; break; } //栈顶元素不匹配，非法
else {a.pop(); break;}//匹配，栈顶元素出栈
case ']': if(a.top()!='[') {islegal = false ; break; }
else {a.pop(); break;}
case '}': if(a.top()!='{') {islegal = false ; break; }
else {a.pop(); break;}
}
if(!islegal) break;//非法退出
}
if(islegal&&a.empty()) cout<<s<<" is a legal string "<<endl;
else cout<<s<<" is an illegal string "<<endl;
system("pause");
return 0;
}

⑶ 去火车站见女友为列有票才能进站,刀具长度小于5才能上车用编程语言怎么写

if(有票&&刀具.长度<5)
{进站}

⑷ 车皮编程问题

OK, 按照你说的堆栈结构，
那么就是5种调度结果。加上一种没有调度的排序1,2,3. 其实它也可以看作是一种调度结果。1进入调度室，又出来；2进入，又出来；3进入又出来。

这个应该是P(3, 3)。基本的数学问题，记得中学好像学过。

你的问题是什么？
是不是想问这个调度站对于长度为n的，能够产生多少种调度结果么？

===============================================================
3 1 2这个结果是不可能的。 所以结果不是简单的P(3,3)这样的排列组合问题。

应该是OK了，费我不少时间，你试试吧。程序很多地方写得不够好，凑合用吧。不想费时间去改进了。
不过我没有删除重复的结果。还需要你自己改进一下，小case。

#define MAX_TRAIN_LEN 100
//#define PRINT_DUMP /* enable this macro to print all detail of scheling */

typedef enum {
GO_OUT_STATION = 0,
GO_IN_STATION,
GO_PASS_STATION
} Action;

static char *action_name[] = {
"go out of station",
"go in station",
"go pass station"
};

int train_len;
int schele_num;

void
printSchele(int pass_train[], int pass_num)
{
int i;

printf("----- got a schele: ");
for (i = 0; i < pass_num; i++)
printf("%d, ", pass_train[i]);
printf("\n");
}

char *
getActionName(Action act)
{
return action_name[act];
}

void
printTrain(char *name, int train[], int begin, int end)
{
int i;

#ifdef PRINT_DUMP
printf("%-20s: ", name);
for (i = begin; i < end; i++)
printf("%d, ", train[i]);
printf("\n");
#else
return;
#endif
}

void
printTrainNum(Action act, int unsched_num, int station_num, int pass_num)
{
#ifdef PRINT_DUMP
printf("%-30s\n (unsched_num: %d, station_num: %d, pass_num: %d)\n", getActionName(act), unsched_num, station_num, pass_num);
#else
return;
#endif
}
void
printRestoreDump()
{
#ifdef PRINT_DUMP
printf("restoring...\n");
#else
return;
#endif

}

/*
Parameters:
int unsched_train[MAX_TRAIN_LEN]; un-scheled train
int unsched_num; un-scheled train number. This is the index
of un-scheled train number. So the
un-scheled trains are in range:
[unsched_num, train_len-1].
int station_train[MAX_TRAIN_LEN]; train in station
int station_num; train number in station, station trains are
in range: [0, station_num-1]
int pass_train[MAX_TRAIN_LEN]; passed train
int pass_num; train number passed already, pass trains are
in range: [0, pass_num-1]
Action act current action
*/

/*
* Three possible action:
* 1) pass directly
* 2) go into scheling station
* 3) if scheling station has any train, go out of station
*/
void
schele(int unsched_train[], int unsched_num, int station_train[], int station_num, int pass_train[], int pass_num, Action act)
{

if (act == GO_OUT_STATION) {
pass_train[pass_num++] = station_train[--station_num];
//printf("%d\n", pass_train[0]);
printTrainNum(act, unsched_num, station_num, pass_num);
printTrain("unsched", unsched_train, unsched_num, train_len);
printTrain("station", station_train, 0, station_num);
printTrain("pass", pass_train, 0, pass_num);
} else if (act == GO_IN_STATION) {
station_train[station_num++] = unsched_train[unsched_num++];
printTrainNum(act, unsched_num, station_num, pass_num);
printTrain("unsched", unsched_train, unsched_num, train_len);
printTrain("station", station_train, 0, station_num);
printTrain("pass", pass_train, 0, pass_num);
} else if (act == GO_PASS_STATION) {
pass_train[pass_num++] = unsched_train[unsched_num++];
printTrainNum(act, unsched_num, station_num, pass_num);
printTrain("unsched", unsched_train, unsched_num, train_len);
printTrain("station", station_train, 0, station_num);
printTrain("pass", pass_train, 0, pass_num);
}

if (unsched_num < train_len) {
if (station_num > 0) {
int old_unsched_train[MAX_TRAIN_LEN], old_station_train[MAX_TRAIN_LEN], old_pass_train[MAX_TRAIN_LEN];
int old_unsched_num, old_station_num, old_pass_num;
memcpy(old_unsched_train, unsched_train, sizeof(int) * train_len);
memcpy(old_station_train, station_train, sizeof(int) * train_len);
memcpy(old_pass_train, pass_train, sizeof(int) * train_len);
old_unsched_num = unsched_num;
old_station_num = station_num;
old_pass_num = pass_num;
schele(unsched_train, unsched_num, station_train, station_num, pass_train, pass_num, GO_OUT_STATION);
printRestoreDump();
unsched_num = old_unsched_num;
station_num = old_station_num;
pass_num = old_pass_num;
memcpy(unsched_train, old_unsched_train, sizeof(int) * train_len);
memcpy(station_train, old_station_train, sizeof(int) * train_len);
memcpy(pass_train, old_pass_train, sizeof(int) * train_len);
printTrain("unsched", unsched_train, unsched_num, train_len);
printTrain("station", station_train, 0, station_num);
printTrain("pass", pass_train, 0, pass_num);
schele(unsched_train, unsched_num, station_train, station_num, pass_train, pass_num, GO_IN_STATION);
printRestoreDump();
unsched_num = old_unsched_num;
station_num = old_station_num;
pass_num = old_pass_num;
memcpy(unsched_train, old_unsched_train, sizeof(int) * train_len);
memcpy(station_train, old_station_train, sizeof(int) * train_len);
memcpy(pass_train, old_pass_train, sizeof(int) * train_len);
printTrain("unsched", unsched_train, unsched_num, train_len);
printTrain("station", station_train, 0, station_num);
printTrain("pass", pass_train, 0, pass_num);
schele(unsched_train, unsched_num, station_train, station_num, pass_train, pass_num, GO_PASS_STATION);
} else {
int old_unsched_train[MAX_TRAIN_LEN], old_station_train[MAX_TRAIN_LEN], old_pass_train[MAX_TRAIN_LEN];
int old_unsched_num, old_station_num, old_pass_num;
old_unsched_num = unsched_num;
old_station_num = station_num;
old_pass_num = pass_num;
memcpy(old_unsched_train, unsched_train, sizeof(int) * train_len);
memcpy(old_station_train, station_train, sizeof(int) * train_len);
memcpy(old_pass_train, pass_train, sizeof(int) * train_len);
schele(unsched_train, unsched_num, station_train, station_num, pass_train, pass_num, GO_IN_STATION);
printRestoreDump();
unsched_num = old_unsched_num;
station_num = old_station_num;
pass_num = old_pass_num;
memcpy(unsched_train, old_unsched_train, sizeof(int) * train_len);
memcpy(station_train, old_station_train, sizeof(int) * train_len);
memcpy(pass_train, old_pass_train, sizeof(int) * train_len);
printTrain("unsched", unsched_train, unsched_num, train_len);
printTrain("station", station_train, 0, station_num);
printTrain("pass", pass_train, 0, pass_num);
schele(unsched_train, unsched_num, station_train, station_num, pass_train, pass_num, GO_PASS_STATION);
}
} else if (station_num > 0) {
schele(unsched_train, unsched_num, station_train, station_num, pass_train, pass_num, GO_OUT_STATION);
} else {
/* get a schele */
if (pass_num != train_len) {
printf("Error: pass_num is not equal to train_len.\n");
exit(1);
}
schele_num++;
printSchele(pass_train, pass_num);
}
}

void main()
{
int unsched_train[MAX_TRAIN_LEN];
int station_train[MAX_TRAIN_LEN];
int pass_train[MAX_TRAIN_LEN];
int i;

printf("Please input train length: ");
scanf("%d", &train_len);
printf("==================================================\n");

if (train_len > MAX_TRAIN_LEN) {
printf("train length is too large, maximal length is %d.\n", MAX_TRAIN_LEN);
exit(1);
}

for (i = 0; i < train_len; i++)
unsched_train[i] = i + 1;

schele_num = 0;
schele(unsched_train, 0, station_train, 0, pass_train, 0, GO_IN_STATION);
printf("==================================================\n");
printf("Total schele number is: %d\n", schele_num);
}

⑸ 通常栈底所指是什么内容,栈顶所指又是什么 (关于51单片机编程)

栈是一种数据结构。先进后出。即LIFO原则。常用于中断断点现场的数据保存与恢复。
栈底指的是堆栈指针sp所指的起始位置begin，当有数据进站后，sp+1；当sp指向的地址为
begin+length；即栈满，此时的sp指向的即为栈顶。
通俗讲，栈底就是第一个进栈的数据，栈顶就是最后一个进栈的数据。。。。
想要深入理解的话，可以去学一学数据结构，对高级编程有很大帮助的！
希望对你有帮助

⑹ 数据结构 有关栈 火车调度的编程 用C语言 要快！！！

本来想写写的，不过看你好像是在应付作业，还是算了吧，我不做害人的事。一不小心就灌水了，对不起，o(∩_∩)o...

你上大学了吧，不容易啊，何必这么堕落，多学点东西才对的起自己，对的起父母，对的起将来。

⑺ 为什么我在三菱PLC编程软件输入MPS,MPP,MPD上面显示“改指令不能用梯形图模式输入”哪位大虾能告诉我啊

t型图里进站读站出站都是直接用画的形式画出来就行了没必要用写的啊，t型输入就是考虑到有些人会画不会变成指令表，你要不会画的话直接跳到软件的指令表输入就行了

⑻ 公交车自动报站是怎么实现的

GPS自动报站