重拾ZOJ 一周解题

ZOJ 2734 Exchange Cards

题目大意：

给定一个值N，以及一堆卡片，每种卡片有一个值value和数量number。求使用任意张卡片组成N的方式。

例如N = 10 ，cards（10,2）（7,2）（5,3）（2,2）（1,5），则10 = 10,10 =7+3+1，10=5+5…

 

思路分析：

由于之前做过1204，知道这题就是赤裸裸的搜索，直接用dfs暴力即可求得。

可做的优化处理就是——这个过程是贪心Greedy的，先从大到小这样取过来，所以，可以做一步降序排列的预处理。

如上例：我选择了7，那么我就不会去选择10，因为加上10太大了，超出了N。

 

知识点总结：

1） DFS走法：沿着可行的解空间往前走；

dfs(index, number, sum, target);

2） 循环走法：选择下一个起点枚举；

dfs(++index, 1, sum, target);

代码：

#include<iostream>

#include<vector>

#include<map>

#include<algorithm>

#include<fstream>

using namespace std;



struct Cards

{

    int num;

    int value;

    bool operator <(const Cards& card)const

    {

        return value > card.value;

    }

};



int totalCardsCount;

vector<Cards> inputValues;



void dfs(int index, int number, int sum, int target)

{

    if (sum == target) //记录总述

    {

        totalCardsCount++;

        return;

    }

    if (index == inputValues.size()) return; //长度



    //能加则加，deep ing ... ...

    if (sum + inputValues[index].value <= target && number <= inputValues[index].num)

    {

        sum += inputValues[index].value;

        number++;

        dfs(index, number, sum, target);

        number--;

        sum -= inputValues[index].value;

    }



    dfs(++index, 1, sum, target);

}



int main()

{

    //ifstream cin("2734.txt");

    int T, i, target;

    int c = 0;

    int n;

    bool first = true;

    while (cin >> target){

        if (!first)

        {

            cout << endl;

        }

        first = false;

        c = 1;

        cin >> n;

        inputValues.clear();

        int tmp;

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

        {

            Cards cd;

            cin >> cd.value;

            cin >> cd.num;

            inputValues.push_back(cd);

        }

        std::sort(inputValues.begin(), inputValues.end());

        totalCardsCount = 0;

        dfs(0, 1, 0, target);

        cout << totalCardsCount << endl;

    }

    return 0;

}

ZOJ 1947 The Settlers of Catan

题目大意：

给出一个无向图，求这个无权无向图的最长路径——the longest path。即，在图中找一条边不重复（点可以重复）的路径，所得的路径的边的条数即为所求。

如：3个点，两条边，（0,1）（1,2），则the longest path 为2。

图的最大规模为25*25。

 

思路分析：

看到这题，试图去网上搜索最长路径的知识点，但是始终找不到有用的。最后，我将起点放在欧拉回路的概念上，然后又了解到哈密顿回路，得出一个结论，求最长路径比欧拉回路更为广泛。

不小心浏览到维基百科，知道这是一个NP问题，其算法只能是暴力枚举。更了解到如果是有向图的最长路径的话应该先做拓扑排序预处理。

于是，直接对每个点进行dfs搜索，每次保存最长路径即可。

 

知识点总结：

1） 欧拉回路：经过图中所有边一次仅一次且行遍所有顶点的回路。

2） 哈密顿回路：经过图中所有顶点一次仅一次的回路。

代码：

#include <stdio.h>

#include<iostream>

#include<vector>

#include<map>

#include<set>

#include<algorithm>

#include<cstring>

#include<fstream>

#include<list>

using namespace std;



int graph[26][26];

bool visited[26][26];



int theLongestPath;

void dfs(int root, int d)

{

    if (d > theLongestPath)

    {

        theLongestPath = d;

    }



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

    {

        if (root == i) continue;

        if (graph[root][i] == 1 && visited[root][i] == 0)

        {

            visited[root][i] = visited[i][root] = 1;

            ++d;

            dfs(i, d);

            --d;

            visited[root][i] = visited[i][root] = 0;

        }

    }

}



int main1947()

{

    //fstream cin("1947.txt");

    int n, m;

    while (cin >> n >> m)

    {

        if (n == 0 && m == 0)break;

        memset(graph, 0, sizeof(graph));



        int start, end;

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

        {

            cin >> start >> end;

            graph[start][end] = graph[end][start] = 1;

        }



        theLongestPath = 0;

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

        {

            memset(visited, 0, sizeof(visited));

            dfs(i, 0);

        }

        cout << theLongestPath << endl;



    }

    return 0;

}

 

ZOJ 1978 Assistant Required

题目大意：

给定一个队列，2，3，。。。n，每次取队首元素作为幸运元素，然后将其后的每隔i个给拖出去干活。比如，第一次2是幸运的，4,6,8…就要干活；第二次3是幸运的，9,15,21。。。就要去干活。。。

求第K个幸运数字。

 

思路分析：

从2写道20的序列分析，发现和素数很像，甚至就做成了素数表。

但当测试第20个幸运数时，Sample Out给出的是83，我打出来的是71（还是73，具体忘了），发现错了，于是再分析之下，发现和素数表有点区别。

素数表：每次去除i的倍数；

幸运数字（暂且这么称吧）表：每次去除每隔i的数。

修改之，即可。

 

知识点总结：

1） 素数表；

代码：

 

#include<iostream>

#include<vector>

#include<map>

#include<string>

#include<algorithm>

#include<fstream>

using namespace std;



const int MAX_Prime = 3001;

const int SEARCH_INT = 34000;



int prime_like[MAX_Prime];

bool is[SEARCH_INT];



void make_prim_table()

{

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

    {

        is[i] = 0;

    }

    int num = 1;

    for (int i = 2; i < SEARCH_INT; i++)

    {

        if (is[i] == 1) continue;

        if (is[i] == 0)

        {

            prime_like[num++] = i;

            if (num == MAX_Prime) break;

        }

        if (i == 2)

        {

            for (int k = i; k < SEARCH_INT; k += i)

            {

                is[k] = 1;

            }

        }

        else

        {

            int number = 0;

            for (int k = i + 1; k < SEARCH_INT; k++)

            {

                if (is[k] == 0)  //已经出队

                {

                    if (++number == i)

                    {

                        is[k] = 1;

                        number = 0;

                    }

                }

            }

        }

    }

}



int main1978()

{

    make_prim_table();

    //fstream cin("1978.txt");

    int n;

    while (true)

    {

        cin >> n;

        if (n == 0)break;

        cout << prime_like[n] << endl;

    }

    return 0;

}

 

Acceptted is the best thing for you ~