A *算法 [英] A* algorithm
问题描述
这是显示*算法实现的程序，给定n
整数和总和m，写一个程序来查找整数集
使用*算法求和为m。
但我没有得到正确的o / p，我只得到一组
整数，是否可以指出所需的错误/更正？
#include< stdio.h>
#include< stdlib .h>
#include< string.h>
typedef enum {FALSE，TRUE} bln;
int subsetsum（ int *，int，int，bln *，int）;
int compare（void *，void *）;
void printanswer（int *，int，bln *） ;
int main（无效）
{
int a [] = {5,3,4,8,9 ，6};
int sum = 15;
int size = sizeof（a）/ sizeof（int）;
int i;
bln * selected = calloc（size，sizeof（bln））;
qsort（a，size，sizeof（int），compare） ;
for（i = 0; i< size; i ++）
{
printf（" \\\
i =％d"，i）;
if（subsetsum（a，size，sum，选中，i））
printanswer（a，尺寸，选中）;
memset（选中，FALSE，尺寸）;
}
返回EXIT_SUCCESS;
}
int subsetsum（int * a，int n，int sum，bln * selected ，int start）
{
int i = start;
if（sum == 0）
返回TRUE;
if（选择[i] == FALSE&& a [i]< = sum）
{
选择[i] = TRUE;
if（subsetsum（a，n，sum） - a [i]，selected，i + 1））
返回TRUE;
选择[i] = FALSE;
}
返回FALSE;
}
void printanswer（int * a，int n，bln *已选中）
{
int i;
for（i = 0; i< n; i ++）
if（选择[i]）
printf（" \t％d"，a [i]）;
put（""）;
}
int compare（void * e1，void * e2）
{
return *（int *）e2 - *（int *）e1;
}
Hi ,
this is the program showing implementation of a* algorithm, given n
integers and a sum m ,write a program to find the set of integers
summing to m using a* algorithm.
but i am not getting the o/p correct , i am getting only one set of
integers, can any one point the errors/corrections required ?
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
typedef enum {FALSE,TRUE}bln;
int subsetsum(int*,int,int,bln* ,int);
int compare(void*,void*);
void printanswer(int*,int,bln*);
int main(void)
{
int a[] = {5,3,4,8,9,6};
int sum = 15;
int size = sizeof(a)/sizeof(int);
int i;
bln *selected = calloc(size,sizeof(bln));
qsort(a,size,sizeof(int),compare);
for(i=0;i < size;i++)
{
printf("\n i = %d",i);
if( subsetsum(a,size,sum,selected,i))
printanswer(a,size,selected);
memset(selected,FALSE,size);
}
return EXIT_SUCCESS;
}
int subsetsum(int *a,int n,int sum,bln *selected ,int start)
{
int i=start;
if(sum == 0)
return TRUE;
if(selected[i] == FALSE && a[i] <= sum)
{
selected[i] = TRUE;
if(subsetsum(a,n,sum - a[i],selected,i+1))
return TRUE;
selected[i] = FALSE;
}
return FALSE;
}
void printanswer(int* a,int n,bln* selected)
{
int i;
for(i=0;i<n;i++)
if(selected[i])
printf("\t%d",a[i]);
puts("");
}
int compare(void* e1,void* e2)
{
return *(int*)e2 - *(int*)e1;
}
推荐答案
2008年4月4日星期五09:11:58 -0700（PDT）， su *** ********@gmail.com
写道：
On Fri, 4 Apr 2008 09:11:58 -0700 (PDT), su***********@gmail.com
wrote:
>
这是显示*算法实现的程序，给定n
整数和和m，写一个程序来找到i的集合ntegers
使用*算法求m。
但我没有得到正确的o / p，我只得到一组
整数，可以任意一点需要错误/更正？
#include< stdio.h>
#include< stdlib.h>
#include< string.h>
typedef enum {FALSE，TRUE} bln;
int subsetsum（int *，int，int，bln *，int）;
int compare（void *，void *）;
void printanswer（int *，int，bln *）;
int main（void）
{
int a [] = {5,3,4,8,9,6};
int sum = 15;
int size = sizeof（a）/ sizeof（int）;
>Hi ,
this is the program showing implementation of a* algorithm, given n
integers and a sum m ,write a program to find the set of integers
summing to m using a* algorithm.
but i am not getting the o/p correct , i am getting only one set of
integers, can any one point the errors/corrections required ?
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
typedef enum {FALSE,TRUE}bln;
int subsetsum(int*,int,int,bln* ,int);
int compare(void*,void*);
void printanswer(int*,int,bln*);
int main(void)
{
int a[] = {5,3,4,8,9,6};
int sum = 15;
int size = sizeof(a)/sizeof(int);
你最好使用sizeof（* a）作为除数。
You would be better off using sizeof(*a) for the divisor.
int i;
bln * selected = calloc（size，sizeof（bln））;
qsort（a，size，sizeof（int），compare ）;
int i;
bln *selected = calloc(size,sizeof(bln));
qsort(a,size,sizeof(int),compare);
您的编译器应报告问题。你的比较函数
没有qsort使用的正确原型。
此处还有sizeof（* a）表示第三个参数。
Your compiler should have reported a problem. Your compare function
does not have the correct prototype to be used by qsort.
Also sizeof(*a) here for the third argument.
>
for（i = 0; i< size; i ++）
{
printf（" \\\
i =％d"，i）;
if（subsetsum（a，size，sum，selected，i））
printanswer（a，size，selected）;
memset（选中，FALSE，大小）;
>
for(i=0;i < size;i++)
{
printf("\n i = %d",i);
if( subsetsum(a,size,sum,selected,i))
printanswer(a,size,selected);
memset(selected,FALSE,size);
这会将所选的前六个字节设置为零。
不幸的是，你不知道选择了什么类型的整数
到。因为你只想在每个整数中存储0和1，所以你可以使bn b成为char的typedef。或者您可以将第三个
参数更改为size * sizeof（* selected），这将重新初始化
整个分配的数组。现在看来，如果bln与
char不一样，那么你不会为下一组
测试重置整个数组。
This sets the first six bytes pointed to by selected to zero.
Unfortunately, you have no idea what type of integer selected points
to. Since you only want to store 0 and 1 in each of the integers, you
could make bln a typedef for char. Or you could change the third
argument to size * sizeof(*selected) which would reinitialize the
entire allocated array. As it stands now, if bln is not the same as
char, you are not resetting the entire array for the next set of
tests.
}
返回EXIT_SUCCESS;
}
int subsetsum（ int * a，int n，int sum，bln * selected，int start）
{
int i = start;
if（sum == 0）
返回TRUE;
if（选择[i] == FALSE&& a [ i]< = sum）
{
选择[i] = TRUE;
if（subsetsum（a，n，sum - a） [i]，selected，i + 1））
}
return EXIT_SUCCESS;
}
int subsetsum(int *a,int n,int sum,bln *selected ,int start)
{
int i=start;
if(sum == 0)
return TRUE;
if(selected[i] == FALSE && a[i] <= sum)
{
selected[i] = TRUE;
if(subsetsum(a,n,sum - a[i],selected,i+1))
可以将startset设置为size-1来调用subsetsum。这个
递归调用然后调用subsetsum并将start设置为size并且然后将
设置为start并且选择[i]和a [i]尝试评估
不存在的对象。这称为未定义的行为。
It is possible to call subsetsum with start set to size-1. This
recursive call would then call subsetsum with start set to size and i
is then set to start and both selected[i] and a[i] attempt to evaluate
non-existent objects. This is called undefined behavior.
返回TRUE;
选择[i] = FALSE;
}
返回FALSE;
}
void printanswer（int * a， int n，bln * selected）
{
int i;
for（i = 0; i< n; i ++ ）
if（选择[i]）
printf（" \t％d"，a [i]）;
puts （""）;
}
int compare（void * e1，void * e2）
{
返回*（int *）e2 - *（int *）e1;
}
return TRUE;
selected[i] = FALSE;
}
return FALSE;
}
void printanswer(int* a,int n,bln* selected)
{
int i;
for(i=0;i<n;i++)
if(selected[i])
printf("\t%d",a[i]);
puts("");
}
int compare(void* e1,void* e2)
{
return *(int*)e2 - *(int*)e1;
}
删除del电子邮件
Remove del for email
Barry Schwarz写道：
Barry Schwarz wrote:
周五，2008年4月4日09:11:58 -0700（PDT）， su *********** @ gmail.com
写道：
On Fri, 4 Apr 2008 09:11:58 -0700 (PDT), su***********@gmail.com
wrote:
< snip>
<snip>
> int compare（void *，void *）;
>int compare(void*,void*);
< snip>
<snip>
>的qsort（一个，大小，的sizeof（int）的，比较）;
> qsort(a,size,sizeof(int),compare);
您的编译器应该报告了一个问题。您的比较函数
没有qsort使用的正确原型。
Your compiler should have reported a problem. Your compare function
does not have the correct prototype to be used by qsort.
它有什么问题？除了缺少的常数？
再见，Jojo
What''s wrong with it? Besides the missing const?
Bye, Jojo
4月5日，1：45 * pm，Barry Schwarz< schwa ... @ dqel.comwrote：
On Apr 5, 1:45*pm, Barry Schwarz <schwa...@dqel.comwrote:
On Fri，2008年4月4日09:11:58 -0700（PDT），sulekhaswe ... @ gmail.com
写道：
On Fri, 4 Apr 2008 09:11:58 -0700 (PDT), sulekhaswe...@gmail.com
wrote:
Hi ,
这是显示*算法实现的程序，给定n
整数和总和m，写一个程序来查找整数集
求和使用*算法。
this is the program showing implementation of a* algorithm, given n
integers and a sum m ,write a program to find the set of integers
summing to m using a* algorithm.
但我没有得到正确的o / p，我只得到一套
整数，可以任意一点需要错误/更正？
but i am not getting the o/p correct , i am getting only one set of
integers, can any one point the errors/corrections required ?
#include< stdio.h>
#include< stdlib.h>
＃包括< string.h中>
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
typedef enum {FALSE，TRUE} bln;
int subsetsum（int *，int，int，bln *， int）;
int compare（void *，void *）;
void printanswer（int *，int，bln *）;
typedef enum {FALSE,TRUE}bln;
int subsetsum(int*,int,int,bln* ,int);
int compare(void*,void*);
void printanswer(int*,int,bln*);
int main（void）
{
int main(void)
{
* int a [] * = {5,3,4,8,9,6};
* int sum * = 15;
* int size = sizeof（a）/ sizeof（int）;
* int a[] *= {5,3,4,8,9,6};
* int sum *= 15;
* int size = sizeof(a)/sizeof(int);
你最好使用sizeof（* a）作为除数。
You would be better off using sizeof(*a) for the divisor.
* int i ;
* int i;
* bln * selected = calloc（size，sizeof（bln））;
* bln *selected = calloc(size,sizeof(bln));
* qsort（a，size，sizeof（int），compare）;
* qsort(a,size,sizeof(int),compare);
您的编译器应该报告了一个问题。 *你的比较函数
没有qsort使用的正确原型。
此处还有sizeof（* a）表示第三个参数。 />
Your compiler should have reported a problem. *Your compare function
does not have the correct prototype to be used by qsort.
Also sizeof(*a) here for the third argument.
* for（i = 0; i< size; i ++）
* {
* * printf（ \\\
i =％d，i）;
* for(i=0;i < size;i++)
* {
* * printf("\n i = %d",i);
* * if（subsetsum（a，size，sum，selected，i））
* * * printanswer（一个，大小，选择的）;
* * if( subsetsum(a,size,sum,selected,i))
* * *printanswer(a,size,selected);
* * memset（选中，FALSE，大小）;
* * memset(selected,FALSE,size);
这会将所选的前六个字节设置为零。
不幸的是，你不知道选择了什么类型的整数
到。 *因为你只想在每个整数中存储0和1，所以
可以使bln成为char的typedef。 *或者您可以将第三个
参数更改为size * sizeof（* selected），这将重新初始化
整个分配的数组。 *现在看来，如果bln与
char不一样，那么你不会为下一组
测试重置整个数组。
This sets the first six bytes pointed to by selected to zero.
Unfortunately, you have no idea what type of integer selected points
to. *Since you only want to store 0 and 1 in each of the integers, you
could make bln a typedef for char. *Or you could change the third
argument to size * sizeof(*selected) which would reinitialize the
entire allocated array. *As it stands now, if bln is not the same as
char, you are not resetting the entire array for the next set of
tests.
*}
* }
* return EXIT_SUCCESS;
}
* return EXIT_SUCCESS;
}
int subsetsum（int * a，int n，int sum，bln * selected，int start）
{
int subsetsum(int *a,int n,int sum,bln *selected ,int start)
{
* int i = start;
* int i=start;
* if（sum == 0）
* *返回TRUE;
* if(sum == 0)
* * return TRUE;
* if（选择[i] == FALSE&& a [i]< = sum）
* {
* * *选择[i] = TRUE;
* * * if（subsetsum（a，n，sum - a [i]，selected，i +1））
* if(selected[i] == FALSE && a[i] <= sum)
* {
* * *selected[i] = TRUE;
* * *if(subsetsum(a,n,sum - a[i],selected,i+1))
可以将startset设置为size-1来调用subsetsum。 *这个
递归调用然后调用subsetsum并将start设置为size并且* i
然后设置为start并且选择[i]和a [i]尝试评估
不存在的对象。 *这称为未定义的行为。
It is possible to call subsetsum with start set to size-1. *This
recursive call would then call subsetsum with start set to size and *i
is then set to start and both selected[i] and a[i] attempt to evaluate
non-existent objects. *This is called undefined behavior.
* * *返回TRUE;
* * *return TRUE;
* * * selected [i] = FALSE;
*}
* * *selected[i] = FALSE;
* }
*返回FALSE;
* return FALSE;
}
}
void printanswer（int * a，int n ，bln *已选择）
{
* * int i;
void printanswer(int* a,int n,bln* selected)
{
* *int i;
* * for（i = 0; i< n; i ++）
* * if（selected [i] ）
* * printf（" \t％d"，a [i]）;
* *for(i=0;i<n;i++)
* * if(selected[i])
* * printf("\t%d",a[i]);
* * puts（""）;
}
* *puts("");
}
int compare（void * e1，void * e2）
{
* * return *（int *）e2 - *（int *）E1;
int compare(void* e1,void* e2)
{
* *return *(int*)e2 - *(int*)e1;
}
}
我试过你所说的如下，但我仍然没有得到正确o /
p
#include< stdio.h>
#include< stdlib.h>
#include< string.h>
/ * typedef enum {FALSE，TRUE} * /
char bln;
int subsetsum（int *，int，int，char *，int）;
int compare（void *，void *）;
void printanswer（int *，int，char *）;
int main（无效）
{
int a [] = {5， 3,4,8,9,6};
int sum = 15;
int size = sizeof（a）/ sizeof（* a）;
int i;
char * selected = calloc（size，sizeof（char））;
qsort（a，size ，sizeof（int），compare）;
for（i = 0; i< size; i ++）
{
printf（" \\\
i =％d"，i）;
if（subsetsum（a，size，sum，selected，i））
printanswer（a，size，selected）;
memset（选中，0，尺寸* sizeof（*已选中））;
}
返回EXIT_SUCCESS;
}
int subsetsum（int * a，int n，int sum，char * selected，int start）
{
int i = start;
if（sum == 0）
返回1;
if（选择[i] == 0&& a [i]< = sum）
{
选择[i] = 1;
if（subsetsum（a，n，sum） - a [i]，选中，i + 1））
返回1;
选择[i] = 0;
}
返回0;
}
void printanswer（int * a，int n，char * selected）
{
int i;
for（i = 0; i< n; i ++）
if（选择[i]）
printf（" \t％d"，a [i]）;
put（""）;
}
int compare（void * e1，void * e2）
{
返回*（int *）e1 - *（int *）e2;
}
我得到o / p如下： -
i = 0
i = 1 4 5 6
i = 2
i = 3
i = 4
i = 5
I tried what u have said as follows , but still i am not get correct o/
p
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
/*typedef enum {FALSE,TRUE}*/
char bln;
int subsetsum(int*,int,int,char* ,int);
int compare(void*,void*);
void printanswer(int*,int,char*);
int main(void)
{
int a[] = {5,3,4,8,9,6};
int sum = 15;
int size = sizeof(a)/sizeof(*a);
int i;
char *selected = calloc(size,sizeof(char));
qsort(a,size,sizeof(int),compare);
for(i=0;i < size;i++)
{
printf("\n i = %d",i);
if( subsetsum(a,size,sum,selected,i))
printanswer(a,size,selected);
memset(selected,0,size * sizeof(*selected));
}
return EXIT_SUCCESS;
}
int subsetsum(int *a,int n,int sum,char *selected ,int start)
{
int i=start;
if(sum == 0)
return 1;
if(selected[i] == 0 && a[i] <= sum)
{
selected[i] = 1;
if(subsetsum(a,n,sum - a[i],selected,i+1))
return 1;
selected[i] = 0;
}
return 0;
}
void printanswer(int* a,int n,char* selected)
{
int i;
for(i=0;i<n;i++)
if(selected[i])
printf("\t%d",a[i]);
puts("");
}
int compare(void* e1,void* e2)
{
return *(int*)e1 - *(int*)e2;
}
I am getting o/p as follows:-
i = 0
i = 1 4 5 6
i = 2
i = 3
i = 4
i = 5
这篇关于A *算法的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持IT屋！
