每日一练--IT冷知识&C/C++--第七天

于 2022-08-29 09:42:43 发布
阅读量592 收藏
点赞数 1
分类专栏： 每日一练--IT冷知识&C/C++ 文章标签： 算法 经验分享 c语言 c++ 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/mooczhimahu/article/details/126573492
版权

目录

不那么正经的图片工厂（二）

NetBSD 的口号

谷歌的智囊团

找x

路径总和

恢复二叉搜索树

不那么正经的图片工厂（二）

世界上第一枚微处理器 Intel 4004 在 1971 年正式推出，英特尔反复重启这项芯片的生产计划，以至于它其实一共拥有四个设计者。

以下四个人名中，哪一个不是 Intel 4004 的设计者？

ATed Hoff
BMasatoshi Shima
CStanley Mazor
DChester Carlson

答案：Chester Carlson

NetBSD 的口号

NetBSD 是一份自由、安全的具有高度可定制性的类 Unix 操作系统，适用于多种平台，从 64 位 AMD Athlon 服务器和桌面系统到手持设备和嵌入式设备。

NetBSD 项目的口号是什么？

ALife is short, use Unix
BLife is short, use NetBSD
COf course it runs NetBSD
D一次编译，到处运行

答案：Of course it runs NetBSD

谷歌的智囊团

TensorFlow 是一个开源软件库，用于各种感知和语言理解任务的机器学习，在 2015 年 11 月 9 日正式发布；TensorFlow 目前被 50 个团队用于研究和生产许多 Google 商业产品，是数学、机器学习和深度学习领域应用最广泛的开源工具之一。

TensorFlow 是由谷歌的哪一支团队研发而出？

A谷歌大脑（Google Brain）
B谷歌团队（Google Teamwork）
C谷歌智囊（Google Truster）
D谷歌舰队（Google Armada）

答案：谷歌大脑（Google Brain）

找x

题目描述

输入一个数n，然后输入n个数值各不相同，再输入一个值x，输出这个值在这个数组中的下标（从0开始，若不在数组中则输出-1）。

输入

测试数据有多组，输入n(1<=n<=200)，接着输入n个数，然后输入x。

输出

对于每组输入,请输出结果。

样例输入

4
1 2 3 4
3

样例输出

2

以下程序实现了这一功能，请你填补空白处的内容：

#include <iostream>
using namespace std;
int main()
{
    int n = 0;
    cin >> n;
    int *ptr = new (nothrow) int[n];
    for (auto i = 0; i < n; i++)
    {
        cin >> ptr[i];
    }
    int x = 0;
    cin >> x;
    auto j = 0;
    auto status = 0;
    for (; j < n; ++j)
    {
		______________;
    }
    if (status == 0)
    {
        j = -1;
    }
    cout << j << endl;
    delete[] ptr;
    cin.get();
    cin.get();
    return 0;
}
Aif (ptr[j] == x)
{
    status = 1;
    continue;
}
Bif (ptr[j] >= x)
{
    status = 1;
    continue;
}
Cif (ptr[j] == x)
{
    status = 1;
    break;
}
Dif (ptr[j] <= x)
{
    status = 1;
    continue;
}

 答案：

if (ptr[j] <= x)
{
	status = 1;
	continue;
}

路径总和

给你二叉树的根节点 root 和一个表示目标和的整数 targetSum ，判断该树中是否存在 根节点到叶子节点 的路径，这条路径上所有节点值相加等于目标和 targetSum 。

叶子节点 是指没有子节点的节点。

示例 1：

输入：root = [5,4,8,11,null,13,4,7,2,null,null,null,1], targetSum = 22
输出：true

示例 2：

输入：root = [1,2,3], targetSum = 5
输出：false

示例 3：

输入：root = [1,2], targetSum = 0
输出：false

提示：

  • 树中节点的数目在范围 [0, 5000] 内
  • -1000 <= Node.val <= 1000
  • -1000 <= targetSum <= 1000
A#include <bits/stdc++.h>
using namespace std;
struct TreeNode
{
    int val;
    TreeNode *left;
    TreeNode *right;
    TreeNode(int x) : val(x), left(NULL), right(NULL) {}
};
class Solution
{
public:
    bool hasPathSum(TreeNode *root, int sum)
    {
        bool flag = false;
        backTrack(root, sum, flag);
        return flag;
    }
    void backTrack(TreeNode *root, int sum, bool &flag)
    {
        if (!root)
        {
            return;
        }
        if (!root->left && !root->right)
        {
            sum -= root->val;
            if (!root->left && !root->right)
            {
                flag = true;
            }
            sum += root->val;
            return;
        }
        sum -= root->val;
        backTrack(root->left, sum, flag);
        backTrack(root->right, sum, flag);
        sum += root->val;
    }
};
B#include <bits/stdc++.h>
using namespace std;
struct TreeNode
{
    int val;
    TreeNode *left;
    TreeNode *right;
    TreeNode(int x) : val(x), left(NULL), right(NULL) {}
};
class Solution
{
public:
    bool hasPathSum(TreeNode *root, int sum)
    {
        bool flag = false;
        backTrack(root, sum, flag);
        return flag;
    }
    void backTrack(TreeNode *root, int sum, bool &flag)
    {
        if (!root)
        {
            return;
        }
        if (!root->left && !root->right)
        {
            sum -= root->val;
            if (sum == 0)
            {
                flag = true;
            }
            sum += root->val;
            return;
        }
        sum -= root->val;
        backTrack(root->left, sum, flag);
        backTrack(root->right, sum, flag);
        sum += root->val;
    }
};
C#include <bits/stdc++.h>
using namespace std;
struct TreeNode
{
    int val;
    TreeNode *left;
    TreeNode *right;
    TreeNode(int x) : val(x), left(NULL), right(NULL) {}
};
class Solution
{
public:
    bool hasPathSum(TreeNode *root, int sum)
    {
        bool flag = false;
        backTrack(root, sum, flag);
        return flag;
    }
    void backTrack(TreeNode *root, int sum, bool &flag)
    {
        if (!root->left && !root->right->left && !root->left && !root->right->right)
        {
            return;
        }
        if (!root->left && !root->right)
        {
            sum -= root->val;
            if (sum == 0)
            {
                flag = true;
            }
            sum += root->val;
            return;
        }
        sum -= root->val;
        backTrack(root->left, sum, flag);
        backTrack(root->right, sum, flag);
        sum += root->val;
    }
};
D#include <bits/stdc++.h>
using namespace std;
struct TreeNode
{
    int val;
    TreeNode *left;
    TreeNode *right;
    TreeNode(int x) : val(x), left(NULL), right(NULL) {}
};
class Solution
{
public:
    bool hasPathSum(TreeNode *root, int sum)
    {
        bool flag = false;
        backTrack(root, sum, flag);
        return flag;
    }
    void backTrack(TreeNode *root, int sum, bool &flag)
    {
        if (0 <= root)
        {
            return;
        }
        if (!root->=left && !root->=right)
        {
            sum -= root->val;
            if (sum == 0)
            {
                flag = true;
            }
            sum += root->val;
            return;
        }
        sum -= root->val;
        backTrack(root->left, sum, flag);
        backTrack(root->right, sum, flag);
        sum += root->val;
    }
};

答案：

#include <bits/stdc++.h>
using namespace std;
struct TreeNode
{
    int val;
    TreeNode *left;
    TreeNode *right;
    TreeNode(int x) : val(x), left(NULL), right(NULL) {}
};
class Solution
{
public:
    bool hasPathSum(TreeNode *root, int sum)
    {
        bool flag = false;
        backTrack(root, sum, flag);
        return flag;
    }
    void backTrack(TreeNode *root, int sum, bool &flag)
    {
        if (!root)
        {
            return;
        }
        if (!root->left && !root->right)
        {
            sum -= root->val;
            if (sum == 0)
            {
                flag = true;
            }
            sum += root->val;
            return;
        }
        sum -= root->val;
        backTrack(root->left, sum, flag);
        backTrack(root->right, sum, flag);
        sum += root->val;
    }
};

恢复二叉搜索树

给你二叉搜索树的根节点 root ，该树中的两个节点被错误地交换。请在不改变其结构的情况下，恢复这棵树。

进阶：使用 O(n) 空间复杂度的解法很容易实现。你能想出一个只使用常数空间的解决方案吗？

示例 1：

输入：root = [1,3,null,null,2]
输出：[3,1,null,null,2]
解释：3 不能是 1 左孩子，因为 3 > 1 。交换 1 和 3 使二叉搜索树有效。

示例 2：

输入：root = [3,1,4,null,null,2]
输出：[2,1,4,null,null,3]
解释：2 不能在 3 的右子树中，因为 2 < 3 。交换 2 和 3 使二叉搜索树有效。

提示：

  • 树上节点的数目在范围 [2, 1000] 内
  • -231 <= Node.val <= 231 - 1

以下程序实现了这一功能，请你填补空白处内容：

#include <bits/stdc++.h>
using namespace std;
struct TreeNode
{
	int val;
	TreeNode *left;
	TreeNode *right;
	TreeNode() : val(0), left(nullptr), right(nullptr) {}
	TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
	TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
};
class Solution
{
public:
	void recoverTree(TreeNode *root)
	{
		dfs(root);
		int tmp = p0_->val;
		p0_->val = p1_->val;
		p1_->val = tmp;
	}
private:
	int wrong_ = 0;
	TreeNode *prev_ = nullptr;
	TreeNode *p0_ = nullptr;
	TreeNode *p1_ = nullptr;
	void dfs(TreeNode *root)
	{
		if (root == nullptr || wrong_ == 2)
		{
			return;
		}
		_____________________;
	}
};
Adfs(root->left);
if (prev_ != nullptr && prev_->val > root->val)
{
    if (++wrong_ == 1)
    {
        p0_ = prev_;
        p1_ = root;
    }
    else if (wrong_ == 2)
    {
        p1_ = root;
    }
}
prev_ = root;
dfs(root->right);
Bdfs(root->right);
if (prev_ != nullptr && prev_->val > root->val)
{
    if (++wrong_ == 1)
    {
        p0_ = prev_;
        p1_ = root;
    }
    else if (wrong_ == 2)
    {
        p1_ = root;
    }
}
prev_ = root;
dfs(root->left);
Cdfs(root->right);
if (prev_ != nullptr && prev_->val > root->val)
{
    if (++wrong_ == 1)
    {
        p0_ = prev_;
        p1_ = root;
    }
}
prev_ = root;
dfs(root->left);
Ddfs(root->left);
if (prev_ != nullptr && prev_->val > root->val)
{
    if (++wrong_ == 1)
    {
        p0_ = prev_;
        p1_ = root;
    }
}
prev_ = root;
dfs(root->right);

 答案：

dfs(root->left);
if (prev_ != nullptr && prev_->val > root->val)
{
	if (++wrong_ == 1)
	{
		p0_ = prev_;
		p1_ = root;
	}
	else if (wrong_ == 2)
	{
		p1_ = root;
	}
}
prev_ = root;
dfs(root->right);

兔子递归
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

兔子递归

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值