请教一个算法问题

Posted 2023-05-13

找出1---50中所有和为100的子集，并输出，例如输出1，49，50或者1，2，47，50等等。没啥思路，望高手点拨一下，感激不尽。给出实现代码的加送200分，说到做到。

mark 楼上几位别乱扯…… 明明是动态规划题目 递归解法

我去敲代码

呃…… 最后求出来的子集数太大，对于和为100的子集，有189477547种，要输出成文本的话估计快要上G了

算法思路：
1. 首先，为了保证不重复求解，如求出1 2和2 1其实是一样的，我们保持最后子集元素递增输出，这样可以避免重复。
2. 用 f(x,y) 表示和为x，且子集中全部的数>=y, 这样的子集，如f(6,2) = (2,4),(2,2,2),(3,3),(6)
3. f(x,y) = (x) 或 (i, f(x-i, i)) ， 其中i>=y
意思就是， 把x本身作为子集， 或者把x中分出一个i, 子集等于 i 加上剩余x-i能分出的子集
4. 总之, 反正就是递归的思路啦

代码如下：（请勿用太大的数测试…… 20以下还可以看看， 20到100请最好用文件输出，最后文本会很大很大…）

#include <iostream>
using namespace std;

int x[103], k = 0, ans = 0;

void f(int sum, int mn)

for (int i=mn; (i<<1)<=sum; i++)
x[k++] = i, f(sum-i, i), k--;
if (sum <= 50)

x[k++] = sum;
for (int i=0; i<k; i++) printf("%d ", x[i]);
printf("\n"), k--, ans++;



int main()

//freopen("out.txt", "w", stdout);
int a;
printf("找出和为多少的子集: ");
scanf("%d", &a);
f(a, 1);
printf("子集数: %d\n", ans);
参考技术A 代码不写了 叫嵌套循环吧
a b c 先是abc等于0

循环C+1
A=0 B=0
if a+b+c等于100
输出 “a+b+c等于0”
C=100 退出循环
<
循环B+1
A=0
if a+b+c等于100
输出 “a+b+c等于0”
B=100 退出循环
（
循环A+1
if a+b+c等于100
输出 “a+b+c等于0”
A=100 退出循环
）
>

大概是这个思路 不知道能不能帮你 参考技术B 给个算法吧，比较笨的，就是累加然后和100比较。

1+2
1+2+3
...
...
1+2+3+...+50

2+3
2+3+4
...
...
2+3+4+...+50

...
...
...

49+50
50 参考技术C #include<stdio.h>
void main()

int a,b,c;
for(a=1;a<=50;a++)
for(b=1;b<=50;b++)
for(c=1;c<=50;c++)
if(a+b+c==100)
if(a!=b&&b!=c&&c!=a)
if(a<b&&b<c)
printf("%d,%d,%d\n",a,b,c);
参考技术D 这个编程当然简单 ， 但是可能性太多了， 输出不完的 第5个回答  2009-10-23 //---------------------------------------------------------------------------

#include <stdio.h>
#include <stdlib.h>
#include <math.h>

void prt(int *data,int len) /*输出找到的方案，如果需要保存到文件，可以在此修改*/

int i;

for (i=0; i<len; i++)
printf("%d\t",data[i]);


putchar('\n');


int fun(int n,int b,int *c,int le) /*从数组c中的下标b开始的元素中找le个元素，使其和为n，输出所有的方案。*/

static int *sp=NULL ;
static int spi=0;
static int sum=0;
int i,free_flag=0;
if (!sp)
sp=(int*)malloc(sizeof(int)*le);
free_flag=1;

if (le)
for (i = b; i>=0; i--)
n-=c[i];
sp[spi++]=c[i];
if (!n&& le==1)
++sum;
prt(sp,spi);

else if (n>0)
fun(n,i-1,c,le-1);

n+=c[i];
spi--;


if (free_flag)

free(sp);
sp=NULL;


return sum;


int max_n(int n) /*用于计算加数个数的最大值*/

double x=(sqrt(1+8*n)-1)/2;
if (fabs(x-floor(x))<1e-6)
return (int)floor(x);

else return (int)floor(x)-1;


int main(int argc, char* argv[])

int num[50];
int i,count=0,max_len=max_n(100);
for (i = 0; i<50; i++) num[i]=i+1;

for (i=1; i<=max_len; i++)

count+=fun(100,49,num,i);
if (count)
printf("到目前为止找到了%d组，是否继续?(y/n)",count);
fflush(stdin);
if (getchar()=='n') break;



printf("共找到了%d组\n",count);
system("pause");

return 0;

//---------------------------------------------------------------------------

请教一个关于二维数组的算法

在下面这样一个6×9二维数组中，需要找出满足1,1,4,1,1这样排列的组合来，记录它们的坐标。

int Array[6][9] =

1,1,0,1,0,0,1,0,0,
4,1,1,0,0,0,1,4,0,
4,0,0,1,1,4,4,1,0,
0,0,0,0,0,1,0,1,0,
0,0,1,1,4,1,0,1,0,
0,0,0,0,4,0,0,0,0,
;

算法越简单越好，能有具体代码更好，我会追加积分的，多谢各位～～
谢谢各位，忘记说清楚了，需要这5个数相连，顺序满足1，1，4，1，1，只能横竖相连，不能斜线相连，

如果仅仅对于6×9这么小的矩阵来说，可以直接循环寻找各个方向的匹配，源代码如下:

#include <cstdio>
#include <cstring>
using namespace std;

int Array[6][9] =

1,1,0,1,0,0,1,0,0,
4,1,1,0,0,0,1,4,0,
4,0,0,1,1,4,4,1,0,
0,0,0,0,0,1,0,1,0,
0,0,1,1,4,1,0,1,0,
0,0,0,0,4,0,0,0,0,
;

int mo[5] = 1,1,4,1,1;

bool check_right(int a,int b) //右方向

int i;
for (i=0;i<5;i++) if (b + i >= 9) return false;
else if (Array[a][b + i] != mo[i]) return false;
return true;


bool check_down(int a,int b) //下方向

int i;
for (i=0;i<5;i++) if (a + i >= 6) return false;
else if (Array[a + i][b] != mo[i]) return false;
return true;


bool check_left_down(int a,int b) //左下方向

int i;
for (i=0;i<5;i++) if (a + i >= 6 || b - i < 0) return false;
else if (Array[a + i][b - i] != mo[i]) return false;
return true;


bool check_right_down(int a,int b) //右下方向

int i;
for (i=0;i<5;i++) if (a + i >= 6 || b + i >= 9) return false;
else if (Array[a + i][b + i] != mo[i]) return false;
return true;


int main()

int i,j;
for (i=0;i<6;i++)
for (j=0;j<9;j++)

if (check_right(i,j)) printf("%d %d right\n",i,j);
if (check_down(i,j)) printf("%d %d down\n",i,j);
if (check_left_down(i,j)) printf("%d %d left_down\n",i,j);
if (check_right_down(i,j)) printf("%d %d right_down\n",i,j);
// 由于模板文本具有回文性质,故只需匹配4个方向,若对于任意模板文本,追加检查剩余的四个方向即可.

return 0;


若对于较为巨大的矩阵以及较多的模板文本，（例如500×500的矩阵，500个文本），如果需要在较短的时间内完成算法（如1秒）需要使用后缀自动机，具体到这个问题就是trie图，一种基于后缀有限状态自动机（Suffix DFA）的专门用于处理多串匹配的数据结构，其构造方法大致是先构造模板文本的trie树，再通过后缀链接生成包含所有转移的trie图。参考源代码如下：
（此代码从控制台读入一个最大支持到1000×1000的字符矩阵，以及最多1000个文本，程序向控制台输出每一个文本在矩阵中的起始位置和方向，以A-H表示八个方向，在Intel Pentium D 2.1G的处理器上对于任何数据均可在1s内完成运算)

#include <stdio.h>
#include <string.h>
int n,m,l,totalnode;
#define N 1100
#define M 1100000
char data[N][N];
char word[N];
typedef struct

int suffix,kind;
int c[26];
trieT;
trieT trie[M];
typedef struct

int a,b;
char oper;
ans_type;
ans_type ans[N];
int Q[M];
char nowoper;
const int thitah[8]=1,1,0,-1,-1,-1,0,1;
const int thital[8]=0,-1,-1,-1,0,1,1,1;

void read_data()

scanf("%d %d %d%*c",&n,&m,&l);
int i,j;
for (i=1;i<=n;i++)

for (j=1;j<=m;j++) scanf("%c",&data[i][j]);data[i][j]-='A';
scanf("%*c");


void insert(int s,int len)

int i,pnt=1;
for (i=len-1;i>=0;i--)

if (trie[pnt].c[word[i]]!=0) pnt=trie[pnt].c[word[i]];
else

totalnode++;
trie[pnt].c[word[i]]=totalnode;
pnt=totalnode;
trie[pnt].kind=-1;trie[pnt].suffix=0;
memset(trie[pnt].c,0,sizeof(trie[pnt].c));


trie[pnt].kind=s;

void init()

totalnode=1;
trie[1].kind=-1;trie[1].suffix=1;
memset(trie[1].c,0,sizeof(trie[1].c));
int i,j,len;
for (i=1;i<=l;i++)

scanf("%s",&word);
len=strlen(word);
for (j=0;j<len;j++) word[j]-='A';
insert(i,len);


void make_trie_graph()

int i,temp,tempnode,cl,op;
cl=0;op=0;
for (i=0;i<26;i++) if (trie[1].c[i]!=0)

temp=trie[1].c[i];
trie[temp].suffix=1;
if (trie[temp].kind==-1) trie[temp].kind=trie[1].kind;
Q[++op]=temp;
else trie[1].c[i]=1;
while (cl<op)

tempnode=Q[++cl];
for (i=0;i<26;i++) if (trie[tempnode].c[i]!=0)

temp=trie[tempnode].c[i];
trie[temp].suffix=trie[trie[tempnode].suffix].c[i];
if (trie[temp].kind==-1) trie[temp].kind=trie[trie[temp].suffix].kind;
Q[++op]=temp;
else trie[tempnode].c[i]=trie[trie[tempnode].suffix].c[i];


void get_ans(int s,int h,int l)

while (trie[s].kind!=-1)

ans[trie[s].kind].a=h;ans[trie[s].kind].b=l;
ans[trie[s].kind].oper=nowoper;
s=trie[s].suffix;


void check(int h,int l)

int pnt=1;
while ((h>0) && (h<=n) && (l>0) && (l<=m))

pnt=trie[pnt].c[data[h][l]];
if (trie[pnt].kind!=-1) get_ans(pnt,h,l);
h+=thitah[nowoper];l+=thital[nowoper];


void work_ans()

int i;
nowoper=0;for (i=1;i<=m;i++) check(1,i);
nowoper=1;for (i=1;i<=m;i++) check(1,i);for (i=2;i<=n;i++) check(i,m);
nowoper=2;for (i=1;i<=n;i++) check(i,m);
nowoper=3;for (i=1;i<=n;i++) check(i,m);for (i=1;i<m;i++) check(n,i);
nowoper=4;for (i=1;i<=m;i++) check(n,i);
nowoper=5;for (i=1;i<=m;i++) check(n,i);for (i=1;i<n;i++) check(i,1);
nowoper=6;for (i=1;i<=n;i++) check(i,1);
nowoper=7;for (i=1;i<=n;i++) check(i,1);for (i=2;i<=m;i++) check(1,i);


void show_ans()

int i;
for (i=1;i<=l;i++) printf("%d %d %c\n",ans[i].a-1,ans[i].b-1,ans[i].oper+'A');


int main()

read_data();
init();
make_trie_graph();
work_ans();
show_ans();
return 0;


若楼主希望学习trie图的具体理论和构造方法，可回帖注明。 参考技术A 你的问题,我还是不太明白,我写了一个简单,但只是针对,你上面的那个,没什么扩展性,你先看看,坐标呢,直接打印,没有写入文件..

#include"T1.h"
#include<iostream>
using namespace std;
const void Sevch(int (&Sj)[6][9],int (&key)[5]);
int main(int argc,char* argv[])

int Array[6][9]=

1,1,4,1,1,4,1,1,0,
4,1,1,0,0,0,1,4,0,
4,0,0,1,1,4,4,1,0,
0,0,0,0,0,1,0,1,0,
0,0,1,1,4,1,1,1,0,
0,0,0,0,4,0,0,0,0,
;
int Key[5]=1,1,4,1,1;
Sevch(Array,Key);
cin.get();

const void Sevch(int (&Sj)[6][9],int (&key)[5])

int Len=6;
int Lie=9;
for(int i=0;i<Len;i++)

for(int j=0;j<Lie;j++)

if(Sj[i][j]==key[0]&&Sj[i][j+1]==key[1]&&Sj[i][j+2]==key[2]&&Sj[i][j+3]==key[3]&&Sj[i][j+4]==key[4])

cout<<"Key:"<<"在"<<i+1<<"行"<<j+1<<"列"<<endl;





V1.1增强版.

#include<iostream>
using namespace std;
const void Sevch_R(int (&Sj)[6][9],int (&key)[5]); //水平方向查找.
const void Secvh_X(int (&Sj)[6][9],int (&key)[5]); //垂直方向查找.
int main(int argc,char* argv[])

int Array[6][9]=

1,1,4,1,1,1,4,1,1,
1,1,1,1,1,1,4,1,1,
4,4,4,1,1,4,4,1,1,
1,1,1,4,1,1,0,1,4,
1,1,1,1,4,1,1,1,1,
1,1,4,1,1,1,4,1,1,
;
int Key[5]=1,1,4,1,1;
cout<<"水平方向的Key有:\n";
Sevch_R(Array,Key);
cout<<"\n垂直方向的Key有:\n";
Secvh_X(Array,Key);
cin.get();


const void Sevch_R(int (&Sj)[6][9],int (&key)[5])

for(int i=0;i<6;i++)

for(int j=0;j<5;j++)

if(Sj[i][j]==key[0]&&Sj[i][j+1]==key[1]&&Sj[i][j+2]==key[2]&&Sj[i][j+3]==key[3]&&Sj[i][j+4]==key[4])

cout<<"Key:"<<"在"<<i+1<<"行"<<j+1<<"列"<<endl;





const void Secvh_X(int (&Sj)[6][9],int (&key)[5])

for(int j=0;j<2;j++)

for(int i=0;i<9;i++)

if(Sj[j][i]==key[0]&&Sj[j+1][i]==key[1]&&Sj[j+2][i]==key[2]&&Sj[j+3][i]==key[3]&&Sj[j+4][i]==key[4])

cout<<"Key:"<<"在"<<j+1<<"行"<<i+1<<"列"<<endl;



参考技术B 修改后，横纵方向各扫一遍
#include <iostream>
using namespace std;
int Array[6][9] =

1,1,0,1,0,0,1,0,0,
4,1,1,0,0,0,1,4,0,
4,0,0,1,1,4,4,1,0,
0,0,0,0,0,1,0,1,0,
0,0,1,1,4,1,0,1,0,
0,0,0,0,4,0,0,0,0,
;
int arrayString[]=1,1,4,0,0;
int main(void)

int y=sizeof(*Array)/sizeof(int);
int x=sizeof(Array)/sizeof(int)/y;
int len=sizeof(arrayString)/sizeof(int);
int i,j,k;
for(i=0;i<x;i++)
for(j=0;j<y-len;j++)
for(k=0;k<len;k++)
if(Array[i][j+k]!=arrayString[k])break;

if(k==len)
cout<<"x="<<j+1<<"y="<<i+1<<endl;


for(i=0;i<x-len;i++)
for(j=0;j<y;j++)
for(k=0;k<len;k++)
if(Array[i+k][j]!=arrayString[k])break;

if(k==len)
cout<<"x="<<j+1<<"y="<<i+1<<endl;


return 0;
参考技术C 只要横向的一组数里面是1，1，4，1，1就行吗？