《算法笔记上机实验指南》第4章 入门篇（2）8.1

A1103： DFS

/*
    南墙：
        1.所选择的数的p次方之和==n+选择底数个数刚好为n
        2.如果有最大的底数之和则更新
        3.然后返回空
    分支：
        1.不用访问0那个数

        2.选择加入：价将底数index加入到临时数组vector中，然后DFS，index就是当前加入到临时数组temp中的那个数，同时总的 选的数字个数要改变 选择的数的p次方之和要改变 总的和也要改变
        3.选择不加入：将刚才那个放入数组中的数，弹出，然后访问下一个，剩下的参数不变

    初始化数组fac：
        1.void 类型
        2.变量 i=0 temp=0
        3.while循环条件：temp<=n,将temp放入到数组中，然后改变temp的值

    index访问的数字就是按照从0开始，进行升序排列的

    其实本道题和例子中那个，就多了一个要访问最优序列


    如果最后的底数之和没有发生任何改变的，就表示么有任何合适的序列，则输出-1
*/

#include<iostream>
#include<vector>
using namespace std;

vector<int> fac,temp,ans;

int n,p,k,maxnbottom=-1;


int power(int x)        //计算x的p次方
{
    int ans=1;
    //等会来看这个问题
    while(p!=0)
    {
        ans*=x;
        p--;
    }
      /*for(int i=0; i<p; i++)
        ans*=x;*/
    return ans;
}

void init()
{
    int temp=0,i=0;
   //for(int temp=0; temp<=n; temp=power(i++))
    while(temp<=n)
    {
        fac.push_back(temp);    //将temp放入到数组vector中其实就是按照0,1,2,3,4,5....的顺序进行放入的
        temp=power(++i);
    }
}

void DFS(int index, int Nown, int sum, int num)      //4个参数分别表示：当前访问的指数，当前访问的底数个数，当前访问的p次方的个数之和，底数之和
{
    if(sum==n && Nown==k)
    {
        if(num>maxnbottom)
        {
            maxnbottom=num;
            ans=temp;
        }
        return ;
    }
    if(sum>n || Nown>k)
        return ;
    if(index-1>=0)
    {
        temp.push_back(index);
        DFS(index,Nown+1,sum+fac[index],num+index);
        temp.pop_back();
        DFS(index-1,Nown,sum,num);
    }
}



int main()
{
    cin >> n >> k >> p;
    init();
    DFS(fac.size()-1,0,0,0);
    if(maxnbottom==-1)
        cout << "Impossible" << endl;
    else
    {
        printf("%d = %d^%d",n,ans[0],p);
        for(int i=1; i<ans.size(); i++)
        {
            printf(" + %d^%d",ans[i],p);
        }
    }
    return 0;

}

这里有个小问题：

//在使用下面这个程序中，对于power函数而言，使用while和for不一样，使用while会导致内存不够，而使用for可以，因为while循环结束后不回从内存中释放掉空间，但是for循环结束后是会从空间中释放掉内存。所以我总结的是，在init的函数中，不管是使用while还是for都不影响，唯一合理的解释是，在init中调用，power函数，是需要开辟空间的，而power函数中使用while是不会释放空间，所以导致内存不够，如果使用for循环，在power函数循环结束时，会释放掉空间，所以不会超过内存
#include<iostream>
#include<vector>
using namespace std;

vector<int> fac,temp,ans;

int n,p,k,maxnbottom=-1;


int power(int x)        //计算x的p次方
{
    int ans=1;

    while(p!=0)
    {
        ans*=x;
        p--;
    }
      /*for(int i=0; i<p; i++)
        ans*=x;*/
    return ans;
}

void init()
{
    int temp=0,i=0;
    while(temp<=n)
    {
        fac.push_back(temp);    //将temp放入到数组vector中其实就是按照0,1,2,3,4,5....的顺序进行放入的
        temp=power(++i);
    }
}


int main()
{
    cin >> n >> k >> p;
    init();
    return 0;
}

A1091 BFS

#include<iostream>
#include<queue>
using namespace std;

//统计的是卒中核心区的1的个数，通过BFS函数计算出每一个合适区域1的个数，然后累加

int n,m,slice,T;

int a[1290][129][61];

int xx[6]={1,-1,0,0,0,0};
int yy[6]={0,0,1,-1,0,0};
int zz[6]={0,0,0,0,1,-1};

struct node
{
    int x,y,z;
}Node;

bool inq[1290][129][61]={false};

bool judge(int x, int y, int z)
{
    if(x<0 || x>=n || y<0 || y>=m || z<0 || z>=slice)
        return false;
    if(a[x][y][z]==0 || inq[x][y][z]==true)
        return false;
    return true;
}

int BFS(int x, int y, int z)
{
    queue<node> q;
    int ans=0;
    Node.x=x;
    Node.y=y;
    Node.z=z;
    inq[x][y][z]=true;
    q.push(Node);
    while(!q.empty())
    {
        node top=q.front();
        q.pop();
        ans++;
        for(int i=0; i<6; i++)
        {
            int newx=top.x+xx[i];
            int newy=top.y+yy[i];
            int newz=top.z+zz[i];
            if(judge(newx,newy,newz))
            {
                Node.x=newx;
                Node.y=newy;
                Node.z=newz;
                q.push(Node);
                inq[newx][newy][newz]=true;
            }
        }
    }
    if(ans>=T)
        return ans;
    else
        return 0;
}

int main()
{
    cin >> n >> m >> slice >> T;
    for(int z=0; z<slice; z++)
        for(int i=0; i<n; i++)
            for(int j=0; j<m; j++)
            {
                cin >> a[i][j][z];
            }
    int all=0;
    for(int z=0; z<slice; z++)
        for(int i=0; i<n; i++)
            for(int j=0; j<m; j++)
            {
                if(a[i][j][z]==1 && inq[i][j][z]==false)
                    all+=BFS(i,j,z);
            }
    cout << all;
}