给几个50行左右简单的C语言程序设计 谢谢~~

#include
#define max 100
int helix(int a,int b,int e,int f,int s[max][max])
{int i;
static int c=1;
for(i=1;i<=e;i++)
s[a++][b]=c++;
f--;
a--;
if(f!=0)
{
for(i=1;i<=f;i++)
s[a][++b]=c++;
e--;
if(e!=0)
{for(i=1;i<=e;i++)
s[--a][b]=c++;
f--;
if(f!=0)
for(i=1;i<=f;i++)
s[a][--b]=c++;
}
}
}
main()
{int m,n,x,y,i=1,j,c,t,s[max][max];
printf("please input the hang&lie number.");
scanf("%d %d %d \n",&m,&n,&t);
x=m;
y=n;
while(1)
{ helix(i,i,x,y,s);
x=x-2;
y=y-2;
if(x<=0||y<=0)
break;
i++;
}
printf("\n");
if(t==0)
{for(i=1;i<=m;i++)
{for(j=1;j<=n;j++)
printf(" %d",s[i][j]);
printf("\n");
}
}
else
{for(i=1;i<=n;i++)
{for(j=1;j<=m;j++)
printf(" %d",s[j][i]);
printf("\n");
}
}
getch();
}
数字的逆序输出，自己尝试著编译看看

在m*n的棋盘上布置k个皇后，使得这k个皇后互不攻击（这里的攻击含义同“八皇后问题”，即两个皇后不可以在同一行，同一列及同一斜线上)。其中1≤m*n≤150,1≤k≤50，时限10s

其实从题目中我们可以推出一个很简单但是很重要的结论，即min(m, n) < 13， 言下之意就是说这个棋盘的较短的一边长度不会超过12，这样就不会对150这个数字感到恐惧了。同样，我们可以断言 k <= min(m, n)。另外一个简单的结论是
f[m][n][k] = f[n][m][k] (f[m][n][k]表示m*n的棋盘放置k个互不攻击的皇后种数)

其次，我们可能想到直接回溯进行硬搜，那很不幸这样是行不通的。为什么行不通，很多相似的状态进行重复的搜索，我们需要把那些相似状态给去除掉，也就是要加上一个强力的剪枝才行。 不难发现，我们要处理的是一个棋盘，而棋盘具有某些对称的性质。通过利用这些性质我们可以有效的减少搜索空间，从而使得效率得到很大提升。（理论上说应该能减少1/4，我在使用过程中为了方便，减少了1/2)

能否更快些呢？记得以前在群里头听讨论说n皇后有个超快的位运算版本，上网搜了搜，发现确实很强悍，如果配合上位运算再加上对称性，那是相当的完美了。(关于n皇后位运算版本的介绍可以参加matrix67的blog的这篇文章)
//农夫三拳@seu
#include
#include

typedef long long i64;

i64 s[151][151][51];
int m, n, x, y;
int MASK;
i64 ans;

void dfs(int m, int n, int row, int ld, int rd, int num, int p, int index)
{
if(num == p)
ans++;
else if(index < m)
{
if(num + m - index > p)
dfs(m, n, row, ld << 1, rd >> 1, num, p, index + 1);
int pos = MASK & ~(row | rd | ld);
while(pos != 0)
{
int pp = pos & -pos;
pos = pos - pp;
dfs(m, n, row + pp, (ld + pp) << 1, (rd + pp) >> 1, num + 1, p, index + 1);
}
}
}

i64 solve(int m, int n, int p)
{
if(s[m][n][p] != -1)
return s[m][n][p];
if(p > n)
return 0;

i64 ret = 0;
int i, j;
for(j = 0; j < n; j++)
{
int pos = 1 << (n - 1 - j);
ans = 0;
dfs(m, n, pos, pos << 1, pos >> 1, 1, p, 1);
ret += ans;
}

s[m][n][p] = ret;

return ret;
}

int main()
{
int i, j;
memset(s, -1, sizeof(s));

while(scanf("%d%d%d%d", &m, &n, &x, &y) == 4)
{
if(m < n && n > 31)
{
int t = m;
m = n;
n = t;
}
if(y > n)
y = n;
MASK = (1 << n) - 1;
i64 res = 0;
if(x == 0)
res++, x = 1;
for(i = x; i <= y; i++)
{
for(j = i; j <= m; j++)
res += solve(j, n, i);
}
printf("%lld\n", res);
}

return 0;
}
后记:
1. 通过实验发现，当给定m*n(n > m)棋盘的时候，在n < 31的范围以内尽量使n较大，反之将m，n进行交换处理，这样可以充分的利用int范围内的位运算的效果。 其实当用64位的位运算之后，速度反而降下来了。
2. 如果利用一行的对称型，我们只要枚举第一个皇后在某行的列的一半就可以了

转换进制小程序

#include
#include
main()
{
void tentotwo(void);
void tentoeight(void);
void tentosixteen(void);
int i,num;
while(1)
{
printf("0.退出 1.十进制~二进制 2.十进制~八进制 3.十进制~十六进制\n");
printf("请选择功能:");
scanf("%d",&i);
switch(i)
{
case 0 : return;
case 1 : tentotwo(); break;
case 2 : tentoeight(); break;
case 3 : tentosixteen(); break;
default : printf("you insert a wrong number.\n"); break;
}
}
}

void tentotwo(void)
{
int n;
char buf[32];
printf("请输入一个十进制整数:");
scanf("%d",&n);
itoa(n, buf, 2);
printf("转换为二进制:%s\n",buf);
}

void tentoeight(void)
{
int n;
char buf[32];
printf("请输入一个十进制整数:");
scanf("%d",&n);
itoa(n, buf, 8);
printf("转换为八进制:%s\n",buf);
}

void tentosixteen(void)
{
int n;
char buf[32];
printf("请输入一个十进制整数:");
scanf("%d",&n);
itoa(n, buf, 16);
printf("转换为十六进制:%s\n",buf);
}