PAT 1053 Path of Equal Weight

#include <cstdio>
#include <cstdlib>
#include <vector>
#include <algorithm>

using namespace std;

vector<vector<int>* > paths;

class Node {
public:
    vector<int> child;
    int weight;
    Node(int w = 0) : weight(w){}
};

int str2num(const char* str) {
    if (str == NULL) return 0;
    int v = 0;
    int i = 0;
    char ch;
    while ((ch = str[i++]) != '\0') {
        v = v * 10 + (ch - '0');
    }
    return v;
}

void print_nodes(vector<Node> &nodes) {
    for (int i=0; i<nodes.size(); i++) {
        printf("id:%d nchild:%d\n", i, nodes[i].child.size());
        for (int j=0; j<nodes[i].child.size(); j++) {
            printf(" %d", nodes[i].child[j]);
        }
        printf("\n");
    }
}

void dfs(vector<Node> &nodes, vector<int> &path, int idx, int sum, int target) {
    if (idx >= nodes.size()) return; // invalid case;
    int path_weight = sum + nodes[idx].weight;
    if (path_weight == target) {
        // not a leaf node, ignore it
        if (!nodes[idx].child.empty()) {
            return;
        }
        // leaf node, so we got a Root->Leaf path weight equal to the target weight
        path.push_back(nodes[idx].weight);
        // record it
        paths.push_back(new vector<int>(path));
        path.pop_back();
        return;
    } else if (path_weight > target) {
        // impossible continue to find a valid path
        return;
    }

    int clen = nodes[idx].child.size();
    for (int i=0; i<clen; i++) {
        path.push_back(nodes[idx].weight);
        dfs(nodes, path, nodes[idx].child[i], path_weight, target);
        path.pop_back();
    }

}
class cmpcls {
private:
    vector<Node>* nodes;
public:
    cmpcls(vector<Node>* ns) : nodes(ns) {}
    bool operator()(int a, int b) {
        if ((*nodes)[a].weight > (*nodes)[b].weight) {
            return true;
        } else {
            return false;
        }
    }
};

bool mycmp(const vector<int>* a, const vector<int>* b) {
    int len = 0;
    if (a->size() > b->size()) {
        len = b->size();
    } else {
        len = a->size();
    }
    for (int i=0; i<len; i++) {
        if ((*a)[i] > (*b)[i]) return true;
    }
    return false;
}

void print_path() {
    int len = paths.size();
    for (int i=0; i<len; i++) {
        int plen = paths[i]->size();
        printf("%d", (*paths[i])[0]);
        for (int j=1; j<plen; j++) {
            printf(" %d", (*paths[i])[j]);
        }
        printf("\n");
    }
}
int main() {
    int N, M, S;

    scanf("%d%d%d", &N, &M, &S);
    vector<Node> nodes(N);

    char buf[4];

    for (int i=0; i<N; i++) {
        int w = 0;
        scanf("%d", &w);
        nodes[i].weight = w;
    }
    cmpcls cmpobj(&nodes);
    
    for (int i=0; i<M; i++) {
        int nchild = 0;
        scanf("%s%d", buf, &nchild);
        Node& node = nodes[str2num(buf)];
        for (int j=0; j<nchild; j++) {
            scanf("%s", buf);
            node.child.push_back(str2num(buf));
        }
        sort(node.child.begin(), node.child.end(), cmpobj);
    }
    vector<int> path;
    dfs(nodes, path, 0, 0, S);
    print_path();
    return 0;
}

原先写的比较函数有问题一直有个case不对，换个思路直接把childnode的顺序按照weight大小来排，这样最终的结果就是按照规定排序。