笔试面试相关记录（7）

（1）

#include 
using namespace std; 
 
int main()
{
    int a[][3] = {1, 2, 3, 4, 5, 6};
    //ptr是一个指向有三个int元素的数组，ptr++是以3*sizeof(int)为单位
    int (*ptr)[3] = a;
    printf("%d%d\n", (*ptr)[1], (*ptr)[2]);
    printf("%p, %p, %p\n", ptr, &a[0][0], a);
    ++ptr;
    printf("%d%d\n", (*ptr)[1], (*ptr)[2]);
    printf("%p, %p, %d, %d\n", ptr, &a[1][0], ptr-a, &a[1][0]-&a[0][0]);
    return 0;
}
输出
23
0x7fff29f6fca0, 0x7fff29f6fca0, 0x7fff29f6fca0
56
0x7fff29f6fcac, 0x7fff29f6fcac, 1, 3

（2）

#include 
using namespace std; 
 
int main()
{
    int arr[5] = {1, 2, 3, 4, 5};
    int * p[5];
    // int* ref[5] = {1, 2, 3, 4, 5}; //编译出错
    int (*p1)[5] = &arr;
    int (&p2)[5] = arr;
    printf("%d, %d, %d\n", (*p1)[1], p2[2], p1[0][2]);
    // 一下三个值相等
    printf("%p, %p, %p", *p1, arr, p1);
    return 0;
}
输出：
2, 3, 3
0x7ffdb545d940, 0x7ffdb545d940, 0x7ffdb545d940

（3）

#include 
using namespace std; 
 
class A {
public:
    A(){cout << "A()" << endl;}
    A(int a){cout << "A(int)" << endl;}
    A(int a, int b){cout << "A(int,int)" << endl;}
};
 
class B:public A{
public:
    B(){cout << "B()" << endl;}
    using A::A;
    
};
 
int main()
{
    B b();
    B c(1);
    B d(1, 2);
    return 0;
}
输出：
A(int)
A(int,int)

（4） 输入n,m，n表示点的个数,m表示查询次数，接下来n-1个点，p2,p3,p4....pn，表示节点 i 的父节点是pi，根节点编号为1，例如输入

3 3
1 1
1 2 3

表示总共3个结点，查询三次，节点2的父节点是1，节点3的父节点是1，对于每次的查询，输出这个点到其他所有点的距离之和，

   1
  /  \
 2   3     查询节点1,则1到2的距离是1,1到3的距离是1，最终结果是2；

              查询节点2，则2到1的距离是1,2到3的距离是2，最终结果是3；

             查询节点3，则3到1的距离是1，3到1的距离是2，最终结果是3；

#include 
#include 
#include 
 
using namespace std;
 
void dfs(vectorint>>& grid, int cur, set<int>& node, int depth, int& sum, int n) {
    if (node.find(cur) == node.end()) {
        sum += depth;
        node.insert(cur);
    }
    for (int i = 1; i <= n; i++) {
        if (node.find(i) == node.end() && grid[cur][i] == 1) {
            dfs(grid, i, node, depth+1, sum, n);
        }
    }
}
 
int main() {
    int n, m;
    while (cin >> n >> m) {
        int t;
        vectorint>> grid(n+1, vector<int>(n+1, 0));
        for (int i = 2; i <= n; i++) {
            cin >> t;
            grid[i][t] = 1;
            grid[t][i] = 1;
        }
        vector<int> ans;
        for (int i = 0; i < m; i++) {
            cin >> t;
            set<int> set_node;
            int sum = 0;
            dfs(grid, t, set_node, 0, sum, n);
            ans.push_back(sum);
        }
        for (int i = 0; i < m; i++) {
            cout << ans[i] << " ";
        }
        cout << endl;
    }
    return 0;
}

（5）输入四个数，n,a,b,c，n表示最多可以进行的操作次数，第 i 次的操作定义为如下：从a,b,c中选取一个严格大于 i 的数字，将其值减去 i ,被剪掉的部分不参与后期的计算，剩下的部分组成新的a,b,c，问a,b,c可以组成多少种面积大于零的三角形。例如如下：

输入5 3 4 5

输出10

(1,4,4)  (2,2,2)  (2,4,3)  (2,4,5)  (3,2,4) (3,3,3) (3,3,5) (3,4,2) (3,4,4) (3,4,5)   10种

解释：最多可以进行5次操作，第一次操作将5变成5-1=4，则（3,4,4）可以组成三角形，第二次操作可以将3变成3-2=1，则（1,4,4）可以组成三角形。以此类推。

#include 
#include 
#include 
#include 
using namespace std;
 
bool check(vector<int>& nums) {
    if (nums[0] + nums[1] > nums[2] && nums[1] + nums[2] > nums[0] && nums[2] + nums[0] > nums[1]) {
        return true;
    }
    return false;
}
 
void backtrace(vector<int> nums, int op, set& set_str, int max_op) {
    if (op > max_op) {
        return;
    }
    if (check(nums)) {
        string nums_str = to_string(nums[0]);
        for (int k = 1; k < 3; k++) {
            nums_str += "-";
            nums_str += to_string(nums[k]);
        }
        set_str.insert(nums_str);
    }
    for (int i = 0; i < 3; i++) {
        vector<int> t = nums;
        if (t[i] > op) {
            t[i] = t[i] - op;
            backtrace(t, op+1, set_str, max_op);
        }
    }
}
 
int main() {
    int n, a, b, c;
    while (cin >> n >> a >> b >> c) {
        vector<int> nums{a, b, c};
        set set_str;
        backtrace(nums, 0, set_str, n);
        for (auto it = set_str.begin(); it != set_str.end(); it++) {
            cout << *it << " ";
        }
        cout << set_str.size() << endl;
    }
    return 0;
}