F 小富的idea （2023河南萌新联赛第四场：河南大学 ）

 

c++；

#include<iostream>
using namespace std;

struct point{
	int x,y,v;
}p[1005];

int f[1005];
int n,q,t,maxn=0x7fffffff,w[1005];

int find(int x){
	return f[x]==x ? x : f[x]=find(f[x]);
}

void merge(int x,int y){
	x=find(x);
	y=find(y);
	if(x!=y)
		f[y]=x;
}

bool check(int i,int j,int t){
	return ((p[i].x-p[j].x)*(p[i].x-p[j].x)+(p[i].y-p[j].y)*(p[i].y-p[j].y))<=((p[i].v+p[j].v)*(p[i].v+p[j].v)*t*t);
}

int solve(){
	cin>>t;
	if(w[t])
		return w[t];
	if(t>maxn)
		return 1;
	int ans=n;
	for(int i=1;i<=n;i++)
		f[i]=i;
	for(int i=1;i<n;i++)
		for(int j=i+1;j<=n;j++){
			if(check(i,j,t)){
				if(find(i)!=find(j))
					ans--;
				merge(i,j);
			}
		}
	if(ans==1 && t<maxn)
		maxn=t;
	return ans;
}

int main(){
	cin>>n;
	for(int i=1;i<=n;i++)
		cin>>p[i].x>>p[i].y>>p[i].v;
	cin>>q;
	while(q--){
		cout<<solve()<<endl;
	}
	return 0;
}

 Python：

import os
import sys
import math
import random
import threading
from copy import deepcopy
from io import BytesIO, IOBase
from types import GeneratorType
from functools import lru_cache, reduce
from bisect import bisect_left, bisect_right
from collections import Counter, defaultdict, deque
from itertools import accumulate, combinations, permutations
from heapq import nsmallest, nlargest, heapify, heappop, heappush
from typing import Generic, Iterable, Iterator, TypeVar, Union, List
from itertools import *
from functools import lru_cache
from collections import *
from heapq import *
import types

BUFSIZE = 4096


class FastIO(IOBase):
    newlines = 0

    def __init__(self, file):
        self._fd = file.fileno()
        self.buffer = BytesIO()
        self.writable = "x" in file.mode or "r" not in file.mode
        self.write = self.buffer.write if self.writable else None

    def read(self):
        while True:
            b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
            if not b:
                break
            ptr = self.buffer.tell()
            self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
        self.newlines = 0
        return self.buffer.read()

    def readline(self):
        while self.newlines == 0:
            b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
            self.newlines = b.count(b"\n") + (not b)
            ptr = self.buffer.tell()
            self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
        self.newlines -= 1
        return self.buffer.readline()

    def flush(self):
        if self.writable:
            os.write(self._fd, self.buffer.getvalue())
            self.buffer.truncate(0), self.buffer.seek(0)


class IOWrapper(IOBase):
    def __init__(self, file):
        self.buffer = FastIO(file)
        self.flush = self.buffer.flush
        self.writable = self.buffer.writable
        self.write = lambda s: self.buffer.write(s.encode("ascii"))
        self.read = lambda: self.buffer.read().decode("ascii")
        self.readline = lambda: self.buffer.readline().decode("ascii")


sys.stdin = IOWrapper(sys.stdin)
sys.stdout = IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
inf = float('inf')
readi = lambda: int(input())
readis = lambda: list(map(int, input().split()))
reads = lambda: input().rstrip()
readss = lambda: input().split()
ascii_lowercase = 'abcdefghijklmnopqrstuvwxyz'


def bootstrap(f, stack=[]):
    def wrappedfunc(*args, **kwargs):
        if stack:
            return f(*args, **kwargs)
        else:
            to = f(*args, **kwargs)
            while True:
                if type(to) is types.GeneratorType:
                    stack.append(to)
                    to = next(to)
                else:
                    stack.pop()
                    if not stack: break
                    to = stack[-1].send(to)

    return wrappedfunc


MOD = 10 ** 9 + 7


ascii_lowercase = 'abcdefghijklmnopqrstuvwxyz'


def slove():
    n = readi()
    a = []
    for _ in range(n):
        x, y, v = readis()
        a.append([x, y, v])
    h = []
    for i in range(n):
        for j in range(i):
            x1, y1, v1 = a[i]
            x2, y2, v2 = a[j]
            d = ((x1 - x2) ** 2 + (y1 - y2) ** 2) ** 0.5
            if v1+v2==0: t=inf
            else: t = d / (v1 + v2)
#             print([x1,y1,v1],[x2,y2,v2],d,t)
            h.append((t, i, j))
    h.sort()
    fa = [i for i in range(n)]

    def find(x):
        t = x
        while fa[x] != x:

            x = fa[x]
        while t != x:
            t, fa[t] = fa[t], x
        return x
    ans = []
    c = n
    queries = []
    q = readi()
    for i in range(q):
        queries.append([readi(), i])
    ans = [1] * (q)
    queries.sort()
    k = 0
    for t, r in queries:
        while k < len(h) and h[k][0] <= t:
            _, i, j = h[k]
            k += 1
            fi, fj = find(i), find(j)
            if fi == fj: continue
            fa[fi] = fj
            c -= 1
        if c==1: break
        ans[r] = c
    for x in ans:
        print(x)
    return
import os

input_file = 'in'
if os.path.exists(input_file):
    file = open(input_file)
    input = file.readline

t = 1

for _ in range(t):
    slove()