针对用于循环PYTHON的数组numpy面向对象编程和pythonfor循环数组这两个问题，本篇文章进行了详细的解答，同时本文还将给你拓展2022-06-25：给定一个正数n,表示有0~n-1号任务，

针对用于循环 PYTHON 的数组 numpy 面向对象编程和python for循环 数组这两个问题，本篇文章进行了详细的解答，同时本文还将给你拓展2022-06-25：给定一个正数 n, 表示有 0~n-1 号任务， 给定一个长度为 n 的数组 time，time [i] 表示 i 号任务做完的时间， 给定一个二维数组 matrix， matrix [j] = {a,、2022-09-03：n块石头放置在二维平面中的一些整数坐标点上 每个坐标点上最多只能有一块石头 如果一块石头的 同行或者同列 上有其他石头存在，那么就可以移除这块石头。 给你一个长度为 n 的数组、2022-12-08：给定 n 棵树，和两个长度为 n 的数组 a 和 b i 号棵树的初始重量为 a [i]，i 号树每天的增长重量为 b [i] 你每天最多能砍 1 棵树，这天收益 = 砍的树初始重量 + 砍的树增长到这天的总、2023-05-03：给你一棵 二叉树 的根节点 root ，树中有 n 个节点 每个节点都可以被分配一个从 1 到 n 且互不相同的值 另给你一个长度为 m 的数组 queries 你必须在树上执行等相关知识，希望可以帮助到你。

• 用于循环 PYTHON 的数组 numpy 面向对象编程（python for循环 数组）
• 2022-06-25：给定一个正数 n, 表示有 0~n-1 号任务， 给定一个长度为 n 的数组 time，time [i] 表示 i 号任务做完的时间， 给定一个二维数组 matrix， matrix [j] = {a,
• 2022-09-03：n块石头放置在二维平面中的一些整数坐标点上 每个坐标点上最多只能有一块石头 如果一块石头的 同行或者同列 上有其他石头存在，那么就可以移除这块石头。 给你一个长度为 n 的数组
• 2022-12-08：给定 n 棵树，和两个长度为 n 的数组 a 和 b i 号棵树的初始重量为 a [i]，i 号树每天的增长重量为 b [i] 你每天最多能砍 1 棵树，这天收益 = 砍的树初始重量 + 砍的树增长到这天的总
• 2023-05-03：给你一棵 二叉树 的根节点 root ，树中有 n 个节点 每个节点都可以被分配一个从 1 到 n 且互不相同的值 另给你一个长度为 m 的数组 queries 你必须在树上执行

用于循环 PYTHON 的数组 numpy 面向对象编程（python for循环 数组）

如何解决用于循环 PYTHON 的数组 numpy 面向对象编程

我正在学习带有数组的 oop 并对数组进行以下程序计数，但该实例不是循环的迭代

import numpy as np
class arr():
    
    def __init__(self):
       self.arr1 = np.array([[1,2,3],[4,5,6],[7,8,9]])
       self.arr1 = self.arr1.reshape(-1)
           
    def cont(self):
        c = 0
        for i in self.arr1:
            if self.arr1[i] > 6:
                c += 1
        return c
rp = arr()
print(rp.cont)
        

解决方法

rp = arr()
print(rp.cont())

2022-06-25：给定一个正数 n, 表示有 0~n-1 号任务， 给定一个长度为 n 的数组 time，time [i] 表示 i 号任务做完的时间， 给定一个二维数组 matrix， matrix [j] = {a,

2022-06-25：给定一个正数 n, 表示有 0~n-1 号任务， 给定一个长度为 n 的数组 time，time [i] 表示 i 号任务做完的时间， 给定一个二维数组 matrix， matrix [j] = {a, b} 代表：a 任务想要开始，依赖 b 任务的完成， 只要能并行的任务都可以并行，但是任何任务只有依赖的任务完成，才能开始。 返回一个长度为 n 的数组 ans，表示每个任务完成的时间。 输入可以保证没有循环依赖。 来自美团。3.26 笔试。

答案 2022-06-25：

拓扑排序基础上做动态规划。

代码用 rust 编写。代码如下：

fn main() {
    let mut time:Vec<i32>=vec![5,3,4,2,7];
    let mut matrix:Vec<Vec<i32>>=vec![vec![0,1],vec![0,2],vec![1,2],vec![3,1],vec![4,0]];
    let ans = finish_time(5,&mut time,&mut matrix);
    println!("ans = {:?}", ans);
}

fn finish_time(n: i32, time: &mut Vec<i32>, matrix: &mut Vec<Vec<i32>>) -> Vec<i32> {
    let mut nexts: Vec<Vec<i32>> = vec![];
    for i in 0..n {
        nexts.push(vec![]);
    }
    let mut in0: Vec<i32> = vec![];
    for _ in 0..n {
        in0.push(0);
    }
    for line in matrix.iter() {
        nexts[line[1] as usize].push(line[0]);
        in0[line[0] as usize] += 1;
    }
    let mut zero_in_queue: Vec<i32> = vec![];
    let mut ans: Vec<i32> = vec![];
    for _ in 0..n {
        ans.push(0);
    }
    for i in 0..n {
        if in0[i as usize] == 0 {
            zero_in_queue.push(i);
        }
    }
    while zero_in_queue.len() > 0 {
        let cur = zero_in_queue[0];
        zero_in_queue.remove(0);
        ans[cur as usize] += time[cur as usize];
        for next in nexts[cur as usize].iter() {
            ans[*next as usize] = get_max(ans[*next as usize], ans[cur as usize]);
            in0[*next as usize] -= 1;
            if in0[*next as usize] == 0 {
                zero_in_queue.push(*next);
            }
        }
    }
    return ans;
}

fn get_max<T: Clone + Copy + std::cmp::PartialOrd>(a: T, b: T) -> T {
    if a > b {
        a
    } else {
        b
    }
}

执行结果如下：

左神 java 代码

2022-09-03：n块石头放置在二维平面中的一些整数坐标点上 每个坐标点上最多只能有一块石头 如果一块石头的 同行或者同列 上有其他石头存在，那么就可以移除这块石头。 给你一个长度为 n 的数组

2022-09-03：n块石头放置在二维平面中的一些整数坐标点上 每个坐标点上最多只能有一块石头 如果一块石头的 同行或者同列 上有其他石头存在，那么就可以移除这块石头。 给你一个长度为 n 的数组 stones ， 其中 stones[i] = [xi, yi] 表示第 i 块石头的位置， 返回 可以移除的石子 的最大数量。 输入: stones = [[0,0],[0,1],[1,0],[1,2],[2,1],[2,2]]。 输出: 5。

答案2022-09-03：

并查集。行代表和列代表合并。

代码用rust编写。代码如下：

use std::collections::HashMap;
fn main() {
    let mut stones = vec![
        vec![0, 0],
        vec![0, 1],
        vec![1, 0],
        vec![1, 2],
        vec![2, 1],
        vec![2, 2],
    ];
    let ans = remove_stones(&mut stones);
    println!("ans = {}", ans);
}

fn remove_stones(stones: &mut Vec<Vec<i32>>) -> i32 {
    let n = stones.len() as i32;
    let mut row_pre: HashMap<i32, i32> = HashMap::new();
    let mut col_pre: HashMap<i32, i32> = HashMap::new();
    let mut uf = UnionFind::new(n);
    for i in 0..n {
        let x = stones[i as usize][0];
        let y = stones[i as usize][1];
        if !row_pre.contains_key(&x) {
            row_pre.insert(x, i);
        } else {
            uf.union(i, *row_pre.get(&x).unwrap());
        }
        if !col_pre.contains_key(&y) {
            col_pre.insert(y, i);
        } else {
            uf.union(i, *col_pre.get(&y).unwrap());
        }
    }
    return n - uf.sets();
}
pub struct UnionFind {
    father: Vec<i32>,
    size: Vec<i32>,
    help: Vec<i32>,
    sets: i32,
}
impl UnionFind {
    fn new(n: i32) -> UnionFind {
        let mut father: Vec<i32> = vec![];
        let mut size: Vec<i32> = vec![];
        let mut help: Vec<i32> = vec![];
        for i in 0..n {
            father.push(i);
            size.push(1);
            help.push(0);
        }
        UnionFind {
            father,
            size,
            help,
            sets: n,
        }
    }

    fn union(&mut self, mut i: i32, mut j: i32) {
        i = self.find(i);
        j = self.find(j);
        if i != j {
            if self.size[i as usize] >= self.size[j as usize] {
                self.father[j as usize] = i;
                self.size[i as usize] += self.size[j as usize];
            } else {
                self.father[i as usize] = j;
                self.size[j as usize] += self.size[i as usize];
            }
            self.sets -= 1;
        }
    }

    fn find(&mut self, mut i: i32) -> i32 {
        let mut s = 0;
        while i != self.father[i as usize] {
            self.help[s] = i;
            s += 1;
            i = self.father[i as usize];
        }
        while s > 0 {
            s -= 1;
            self.father[self.help[s] as usize] = i;
        }
        return i;
    }

    fn sets(&mut self) -> i32 {
        self.sets
    }
}

执行结果如下：

左神java代码

2022-12-08：给定 n 棵树，和两个长度为 n 的数组 a 和 b i 号棵树的初始重量为 a [i]，i 号树每天的增长重量为 b [i] 你每天最多能砍 1 棵树，这天收益 = 砍的树初始重量 + 砍的树增长到这天的总

2022-12-08：给定 n 棵树，和两个长度为 n 的数组 a 和 b i 号棵树的初始重量为 a [i]，i 号树每天的增长重量为 b [i] 你每天最多能砍 1 棵树，这天收益 = 砍的树初始重量 + 砍的树增长到这天的总增重 给定 m，表示你有 m 天，返回 m 天内你获得的最大收益。

答案 2022-12-08：

排序 + 贪心。

代码用 rust 编写。代码如下：

use std::iter::repeat;
fn main() {
    unsafe {
        let ins = [2, 2, 1, 10, 10, 1, 1, 2, 2, 8, 10, 2, 3];
        let mut ii = 0;
        let testCases = ins[ii];
        ii += 1;
        for i in 0..testCases {
            //
            let n = ins[ii];
            ii += 1;
            let m = ins[ii];
            ii += 1;
            for j in 0..n {
                tree[j as usize][0] = ins[ii];
                ii += 1;
            }
            for j in 0..n {
                tree[j as usize][1] = ins[ii];
                ii += 1;
            }
            let ans = max_weight(n, m);
            println!("ans = {}", ans);
        }
    }
}

static mut tree: [[i32; 2]; 250] = [[0; 2]; 250];
static mut dp: [[i32; 250]; 250] = [[0; 250]; 250];
// tree[][]
// i棵树，初始重量 ， tree[i][0]
// i棵树，每天的增长重量 ，tree[i][1]
fn max_weight(n: i32, m: i32) -> i32 {
    unsafe {
        //Arrays.sort(tree, 0, n, (o1, o2) -> o1[1] - o2[1]);
        tree[..n as usize].sort_by(|a, b| a[1].cmp(&b[1]));
        dp[0][0] = tree[0][0];
        for i in 1..n {
            dp[i as usize][0] = get_max(dp[(i - 1) as usize][0], tree[i as usize][0]);
        }
        for j in 1..m {
            dp[0][j as usize] = dp[0][(j - 1) as usize] + tree[0][1];
        }
        for i in 1..n {
            for j in 1..m {
                dp[i as usize][j as usize] = get_max(
                    dp[(i - 1) as usize][j as usize],
                    dp[(i - 1) as usize][(j - 1) as usize]
                        + tree[i as usize][0]
                        + tree[i as usize][1] * j,
                );
            }
        }
        return dp[(n - 1) as usize][(m - 1) as usize];
    }
}

fn get_max<T: Clone + Copy + std::cmp::PartialOrd>(a: T, b: T) -> T {
    if a > b {
        a
    } else {
        b
    }
}

执行结果如下：

左神 java 代码

2023-05-03：给你一棵 二叉树 的根节点 root ，树中有 n 个节点 每个节点都可以被分配一个从 1 到 n 且互不相同的值 另给你一个长度为 m 的数组 queries 你必须在树上执行

2023-05-03：给你一棵 二叉树 的根节点 root ，树中有 n 个节点

每个节点都可以被分配一个从 1 到 n 且互不相同的值

另给你一个长度为 m 的数组 queries

你必须在树上执行 m 个 独立 的查询，其中第 i 个查询你需要执行以下操作：

从树中 移除 以 queries[i] 的值作为根节点的子树

题目所用测试用例保证 queries[i] 不 等于根节点的值。

返回一个长度为 m 的数组 answer ，其中 answer[i] 是执行第 i 个查询后树的高度。

注意：

查询之间是独立的，所以在每个查询执行后，树会回到其 初始 状态。

树的高度是从根到树中某个节点的 最长简单路径中的边数 。

输入：root = [5,8,9,2,1,3,7,4,6], queries = [3,2,4,8]。

输出：[3,2,3,2]。

答案2023-05-03：

大体过程：

1.定义和初始化全局变量

• 使用常量 MAXN 定义数组大小。

• 定义用于深度优先搜索的四个数组 dfn、deep、size、maxl、maxr 和一个计数器 n，保存每个节点的编号、深度、子树大小、左右子树的最大深度。

2.定义深度优先搜索函数 dfs

• 用一个计数器 i 记录当前节点的编号，并将其存储到数组 dfn 中。

• 将当前节点的深度 h 存储到数组 deep 中。

• 将当前节点的子树大小初始化为 1，存储到数组 size 中。

• 如果当前节点存在左孩子，则递归调用 dfs 函数，并将当前节点的子树大小加上其左孩子的子树大小。

• 如果当前节点存在右孩子，则递归调用 dfs 函数，并将当前节点的子树大小加上其右孩子的子树大小。

3.在主函数中创建一棵二叉树 root 和一个查询数组 queries。

4.对于每个查询 queries[i]，执行以下操作：

• 计算以 queries[i] 为根节点的子树编号范围，即 dfn[queries[i]] 到 dfn[queries[i]]+size[dfn[queries[i]]]-1。

• 将该范围内所有节点的深度保存到数组 maxl 中，并计算其前缀最大值。

• 将该范围内所有节点的深度保存到数组 maxr 中，并计算其后缀最大值。

• 计算左右子树的最大深度，取其中的较大值作为删除子树后树的高度。

• 将结果保存到答案数组 ans 中。

5.返回答案数组。

注意：在每次查询中，需要重新计算左右子树的最大深度，因为每次查询都会修改树的结构。

时间复杂度：

在 dfs 函数中，对于每个节点最多访问一次，因此该函数的时间复杂度为 O(n)，其中 n 是二叉树的节点数。

在 treeQueries 函数中，需要处理 $m$ 个查询，对于每个查询需要计算左右子树的最大深度，时间复杂度为 O(n)，因此总时间复杂度为 O(mn)。

空间复杂度：

在 C++ 中，数组和变量的空间占用量是固定的，因此空间复杂度主要取决于递归调用时堆栈的空间占用量。由于最坏情况下二叉树可能退化成一个链表，因此堆栈空间的最大使用量为 O(n)，其中 n 是二叉树的节点数。

除了堆栈空间之外，还需要使用常量大小的额外空间来存储全局变量和临时变量，因此总空间复杂度为 O(n)。

go完整代码如下：

package main

import (
	"fmt"
)

type TreeNode struct {
    Val   int
    Left  *TreeNode
    Right *TreeNode
}

const MAXN = 100010

var dfn [MAXN]int
var deep [MAXN]int
var size [MAXN]int
var maxl [MAXN]int
var maxr [MAXN]int
var n int

func treeQueries(root *TreeNode, queries []int) []int {
	n = 0
	dfs(root, 0)
	for i := 1; i <= n; i++ {
		maxl[i] = max(maxl[i-1], deep[i])
	}
	maxr[n+1] = 0
	for i := n; i >= 1; i-- {
		maxr[i] = max(maxr[i+1], deep[i])
	}
	m := len(queries)
	ans := make([]int, m)
	for i := 0; i < m; i++ {
		leftMax := maxl[dfn[queries[i]]-1]
		rightMax := maxr[dfn[queries[i]]+size[dfn[queries[i]]]]
		ans[i] = max(leftMax, rightMax)
	}
	return ans
}

func dfs(head *TreeNode, h int) {
	i := n + 1
	dfn[head.Val] = i
	deep[i] = h
	size[i] = 1
	n = i
	if head.Left != nil {
		dfs(head.Left, h+1)
		size[i] += size[dfn[head.Left.Val]]
	}
	if head.Right != nil {
		dfs(head.Right, h+1)
		size[i] += size[dfn[head.Right.Val]]
	}
}

func max(a, b int) int {
	if a > b {
		return a
	}
	return b
}

func main() {
	root := &TreeNode{
		Val: 5,
		Left: &TreeNode{
			Val: 8,
			Left: &TreeNode{
				Val:   2,
				Left:  nil,
				Right: nil,
			},
			Right: &TreeNode{
				Val:   9,
				Left:  nil,
				Right: nil,
			},
		},
		Right: &TreeNode{
			Val: 3,
			Left: &TreeNode{
				Val:   1,
				Left:  nil,
				Right: nil,
			},
			Right: &TreeNode{
				Val: 7,
				Left: &TreeNode{
					Val:   4,
					Left:  nil,
					Right: nil,
				},
				Right: &TreeNode{
					Val:   6,
					Left:  nil,
					Right: nil,
				},
			},
		},
	}
	queries := []int{3, 2, 4, 8}
	ans := treeQueries(root, queries)
	fmt.Println("The query results are:", ans)
}

c完整代码如下：

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#define MAXN 100010

struct TreeNode {
    int val;
    struct TreeNode* left;
    struct TreeNode* right;
};

int dfn[MAXN];
int deep[MAXN];
int size[MAXN];
int maxl[MAXN];
int maxr[MAXN];
int n;

int max0(int a, int b) {
    return a > b ? a : b;
}

void dfs(struct TreeNode* head, int h);
int* treeQueries(struct TreeNode* root, int* queries, int queriesSize, int* returnSize);

int main() {
    struct TreeNode node9 = { 9, NULL, NULL };
    struct TreeNode node8 = { 8, NULL, &node9 };
    struct TreeNode node2 = { 2, NULL, NULL };
    struct TreeNode node4 = { 4, NULL, NULL };
    struct TreeNode node1 = { 1, NULL, NULL };
    struct TreeNode node6 = { 6, NULL, NULL };
    struct TreeNode node7 = { 7, &node4, &node6 };
    struct TreeNode node3 = { 3, &node1, &node7 };
    struct TreeNode node5 = { 5, &node8, &node3 };
    struct TreeNode* root = &node5;
    int queries[] = { 3, 2, 4, 8 };
    int queriesSize = sizeof(queries) / sizeof(int);
    int returnSize = 0;
    int* ans = treeQueries(root, queries, queriesSize, &returnSize);
    printf("The query results are: [");
    for (int i = 0; i < returnSize; i++) {
        if (i > 0) {
            printf(", ");
        }
        printf("%d", ans[i]);
    }
    printf("]\n");
    free(ans);
    return 0;
}

void dfs(struct TreeNode* head, int h) {
    int i = ++n;
    dfn[head->val] = i;
    deep[i] = h;
    size[i] = 1;
    if (head->left != NULL) {
        dfs(head->left, h + 1);
        size[i] += size[dfn[head->left->val]];
    }
    if (head->right != NULL) {
        dfs(head->right, h + 1);
        size[i] += size[dfn[head->right->val]];
    }
}

int* treeQueries(struct TreeNode* root, int* queries, int queriesSize, int* returnSize) {
    n = 0;
    dfs(root, 0);
    int i;
    for (i = 1; i <= n; i++) {
        maxl[i] = max0(maxl[i - 1], deep[i]);
    }
    maxr[n + 1] = 0;
    for (i = n; i >= 1; i--) {
        maxr[i] = max0(maxr[i + 1], deep[i]);
    }
    int* ans = (int*)malloc(queriesSize * sizeof(int));
    for (i = 0; i < queriesSize; i++) {
        int leftMax = maxl[dfn[queries[i]] - 1];
        int rightMax = maxr[dfn[queries[i]] + size[dfn[queries[i]]]];
        ans[i] = max0(leftMax, rightMax);
    }
    *returnSize = queriesSize;
    return ans;
}

c++完整代码如下：

#include <iostream>
#include <vector>

using namespace std;

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

const int MAXN = 100010;
int dfn[MAXN];
int deep[MAXN];
int size0[MAXN];
int maxl[MAXN];
int maxr[MAXN];
int n;

void dfs(TreeNode* head, int h) {
    int i = ++n;
    dfn[head->val] = i;
    deep[i] = h;
    size0[i] = 1;
    if (head->left != nullptr) {
        dfs(head->left, h + 1);
        size0[i] += size0[dfn[head->left->val]];
    }
    if (head->right != nullptr) {
        dfs(head->right, h + 1);
        size0[i] += size0[dfn[head->right->val]];
    }
}

vector<int> treeQueries(TreeNode* root, vector<int>& queries) {
    n = 0;
    dfs(root, 0);
    for (int i = 1; i <= n; i++) {
        maxl[i] = max(maxl[i - 1], deep[i]);
    }
    maxr[n + 1] = 0;
    for (int i = n; i >= 1; i--) {
        maxr[i] = max(maxr[i + 1], deep[i]);
    }
    int m = (int)queries.size();
    vector<int> ans(m);
    for (int i = 0; i < m; i++) {
        int leftMax = maxl[dfn[queries[i]] - 1];
        int rightMax = maxr[dfn[queries[i]] + size0[dfn[queries[i]]]];
        ans[i] = max(leftMax, rightMax);
    }
    return ans;
}

int main() {
    TreeNode node9(9);
    TreeNode node8(8);
    node8.right = &node9;
    TreeNode node2(2);
    TreeNode node4(4);
    TreeNode node1(1);
    TreeNode node6(6);
    TreeNode node7(7);
    node7.left = &node4;
    node7.right = &node6;
    TreeNode node3(3);
    node3.left = &node1;
    node3.right = &node7;
    TreeNode node5(5);
    node5.left = &node8;
    node5.right = &node3;
    vector<int> queries{ 3, 2, 4, 8 };
    auto ans = treeQueries(&node5, queries);
    cout << "The query results are: [";
    for (int i = 0; i < ans.size(); i++) {
        if (i > 0) {
            cout << ", ";
        }
        cout << ans[i];
    }
    cout << "]" << endl;
    return 0;
}

关于用于循环 PYTHON 的数组 numpy 面向对象编程和python for循环 数组的介绍已经告一段落，感谢您的耐心阅读，如果想了解更多关于2022-06-25：给定一个正数 n, 表示有 0~n-1 号任务， 给定一个长度为 n 的数组 time，time [i] 表示 i 号任务做完的时间， 给定一个二维数组 matrix， matrix [j] = {a,、2022-09-03：n块石头放置在二维平面中的一些整数坐标点上 每个坐标点上最多只能有一块石头 如果一块石头的 同行或者同列 上有其他石头存在，那么就可以移除这块石头。 给你一个长度为 n 的数组、2022-12-08：给定 n 棵树，和两个长度为 n 的数组 a 和 b i 号棵树的初始重量为 a [i]，i 号树每天的增长重量为 b [i] 你每天最多能砍 1 棵树，这天收益 = 砍的树初始重量 + 砍的树增长到这天的总、2023-05-03：给你一棵 二叉树 的根节点 root ，树中有 n 个节点 每个节点都可以被分配一个从 1 到 n 且互不相同的值 另给你一个长度为 m 的数组 queries 你必须在树上执行的相关信息，请在本站寻找。