腾讯音乐笔试

一、 树自上往下每层循环右移k位

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

struct TreeNode {
    int val;
    struct TreeNode *left;
    struct TreeNode *right;
    TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
};


class Solution {
public:
    void rMoveK(deque<TreeNode*> &nodeQueue, int k)
    {
        int n = nodeQueue.size();
        k %= n;
        for(int i=0; i<k; i++)
        {
            TreeNode *b = nodeQueue.back();
            nodeQueue.pop_back();
            nodeQueue.push_front(b);
        }
    }

    TreeNode* cyclicShiftTree(TreeNode* root, int k)
    {
        if(root == NULL ) return root;
        TreeNode *bRoot = root;

        deque<deque<TreeNode*> > LNodes;

        deque<TreeNode*> nodeDeque;
        nodeDeque.push_back(root);

        while(!nodeDeque.empty())
        {
            rMoveK(nodeDeque,k);
            deque<TreeNode *> tempDeque;
            int n = nodeDeque.size();
            for(int i=0; i<n; i++)
            {
                TreeNode *t = nodeDeque.front();
                nodeDeque.pop_front();
                tempDeque.push_back(t);
                if(t == NULL) continue;
                nodeDeque.push_back(t->left);
                nodeDeque.push_back(t->right);
            }
            LNodes.push_back(tempDeque);
        }


        //重新建立上下层的指向关系
        for(int i=0; i<LNodes.size()-1; i++)
        {
            int k = 0;
            for(int j=0; j<LNodes[i].size(); j++)
            {
                if(LNodes[i][j] == NULL) {
                    continue;
                }
                else{
                    LNodes[i][j]->left = LNodes[i+1][k++];
                    LNodes[i][j]->right = LNodes[i+1][k++];
                }
            }

        }
        return bRoot;

    }
};

void printTree(TreeNode* pRoot) {
    vector<vector<int> > res;
    if (!pRoot) return;
    deque<TreeNode *> nodeQueue;
    nodeQueue.push_back(pRoot);
    while (!nodeQueue.empty()) {
        vector<int> temp;
        for (auto iter = nodeQueue.begin(); iter != nodeQueue.end(); ++iter) {
            temp.push_back((*iter)->val);
        }
        res.push_back(temp);

        int n = nodeQueue.size();
        for (int i = 0; i < n; i++) {
            TreeNode *temp = nodeQueue.front();
            nodeQueue.pop_front();
            if (temp->left) nodeQueue.push_back(temp->left);
            if (temp->right) nodeQueue.push_back(temp->right);
        }
    }
    for(auto x:res)
    {
        for(auto y:x)
        {
            cout<<y<<" ";
        }
        cout<<endl;
    }
    cout<<endl;
}


int main()
{
    TreeNode *node1 = new TreeNode(1);
    TreeNode *node2 = new TreeNode(2);
    TreeNode *node3 = new TreeNode(3);
    TreeNode *node4 = new TreeNode(4);
    TreeNode *node5 = new TreeNode(5);

    node1->left = node2;
    node1->right = node3;
    node3->left = node4;
    node3->right = node5;

    printTree(node1);

    Solution sol;
    node1 = sol.cyclicShiftTree(node1,2);
    printTree(node1);
}

二、 k进制，最小m使得1出现的次数>n

#include <vector>
#include <iostream>
#include <algorithm>
#include <map>
#include <stack>
#include <deque>
using namespace  std;

class Solution {
public:
    long long int NumberOf1Between1AndN_Solution(long long int n, int z) {
        vector<long long int> nums;
        while(n)
        {
            nums.push_back(n%z);
            n /= z;
        }

        long long int res = 0;
        for(long long int i=nums.size()-1; i >= 0 ;i--)
        {
            long long int left=0, right = 0, x = 1;

            for(long long int j = nums.size()-1; j >i; j--)
                left = left * z + nums[j];

            for(long long int k = i-1; k >= 0; k--)
            {
                right = right *z + nums[k];
                x *= z;
            }

            res += left * x;
            if(nums[i] == 1) res += right + 1;
            else if(nums[i] > 1) res += x;

        }
        return res;
    }

    long long minM(long long int n, int k) {
        long long int r = (long long int) 1e9;
        long long int l = 1;
        while(l<=r)
        {
            long long int mid = l + (r - l)/2;
            long long temp = NumberOf1Between1AndN_Solution(mid,k);
            if(temp == n) return mid;
            if(temp < n)
            {
                l = mid+1;
            }
            else if (temp > n)
            {
                r = mid - 1;
            }
        }
        if (NumberOf1Between1AndN_Solution(l,k) == n)
            return l;

        if (NumberOf1Between1AndN_Solution(l,k) > n)
        {
            while (NumberOf1Between1AndN_Solution(l,k) > n)
            {
                l--;
            }
            return l+1;
        }
        else
        {
            while (NumberOf1Between1AndN_Solution(l,k) < n)
            {
                l++;
            }
            return l-1;
        }
        return l;
    }
};
int main()
{
    Solution sol;
    long long ans = sol.minM(10,10);
//    long long ans = sol.NumberOf1Between1AndN_Solution(10,10);
    cout<<ans<<endl;

}