将类似的盒子分组
我有一组（X，Y）坐标，它将单位正方形划分为子矩形。假设我的坐标是 -
( x1, y1) ( x2, y2)
(0.0000,0.0000) (0.3412,0.4175)
(0.7445,0.0000) (1.0000,0.6553)
(0.7445,0.6553) (1.0000,1.0000)
(0.0000,0.6553) (0.7445,1.0000)
(0.3412,0.0000) (0.7445,0.4175)
(0.3412,0.4175) (0.7445,0.6553)
(0.0000,0.4175) (0.3412,0.6553)....etc (total 10,000 coordinates)
作为一个例子，我只拿了16组数据，这些坐标像这样分割我的方块 -
类似框的定义
具有相似数量的邻居的那些盒子被视为类似的盒子。对于框[8]上方的图像，框[13] 等具有 4 最近邻居。所以他们被认为是类似的盒子。
下面的图片应该清楚 -
::我的问题::
从图中我们可以看到 -
对于框[8] ，最近的框是：
框（1）（有4个邻居）
框[4]（也有4个邻居）
框[14]（有4个邻居）
方框[16]（有4个邻居）
因此，在这种情况下，最近框的邻居之和= 4 + 4 + 4 + 4 = 16
再次 框[13] 最近的框是：
框[3]（有6个邻居）
框[5]（也有4个邻居）
框[6]（有3个邻居）
框[12]（有3个邻居）
因此，在这种情况下，最近框的邻居之和= 6 + 4 + 3 + 3 = 16
这里（类似方框）框[8]和方框[13]的邻居总数= 16 + 16 = 32。
类似地，我想将所有具有4个邻居的框分组，并找到最近框的邻居之和。并继续为每个类似的团体。
我的代码
这是我的代码。
#include <iostream>
#include <cstdlib>
#include <vector>
#include <stdio.h>
using namespace std;
class Rect {
public:
double x1, x2, y1, y2; // coordinates
Rect(double X1, double Y1, double X2, double Y2) {
if (X1 < X2) {
x1 = X1; x2 = X2;
} else {
x2 = X1; x1 = X2;
}
if (Y1 < Y2) {
y1 = Y1; y2 = Y2;
} else {
y2 = Y1; y1 = Y2;
}
}
bool isAdjacent(Rect rect) {
if (x1 == rect.x1 || x1 == rect.x2 ||
x2 == rect.x1 || x2 == rect.x2) {
// use only < when comparing y1 and rect.y2 avoids sharing only a corner
if (y1 >= rect.y1 && y1 < rect.y2) {
return true;
}
if (y2 > rect.y1 && y2 <= rect.y2) {
return true;
}
if (rect.y1 >= y1 && rect.y1 < y2) {
return true;
}
if (rect.y2 > y1 && rect.y2 <= y2) {
return true;
}
}
if (y1 == rect.y1 || y1 == rect.y2 ||
y2 == rect.y1 || y2 == rect.y2) {
if (x1 >= rect.x1 && x1 < rect.x2) {
return true;
}
if (x2 > rect.x1 && x2 <= rect.x2) {
return true;
}
if (rect.x1 >= x1 && rect.x1 < x2) {
return true;
}
if (rect.x2 > x1 && rect.x2 <= x2) {
return true;
}
}
return false;
}
};
void isNearest(int b){
vector<Rect> rects;
//Rect( x1 , y1 , x2 , y2 )
rects.push_back(Rect(0.0000,0.0000, 0.8147,0.1355));
rects.push_back(Rect(0.8147,0.0000, 1.0000,0.1355));
rects.push_back(Rect(0.8147,0.1355, 0.9058,0.8350));
rects.push_back(Rect(0.0000,0.1355, 0.1270,0.9689));
rects.push_back(Rect(0.9058,0.1355, 0.9134,0.2210));
rects.push_back(Rect(0.9058,0.8350, 1.0000,1.0000));
rects.push_back(Rect(0.8147,0.8350, 0.9058,1.0000));
rects.push_back(Rect(0.1270,0.1355, 0.6324,0.3082));
rects.push_back(Rect(0.1270,0.9689, 0.8147,1.0000));
rects.push_back(Rect(0.0000,0.9689, 0.1270,1.0000));
rects.push_back(Rect(0.9134,0.1355, 1.0000,0.2210));
rects.push_back(Rect(0.9134,0.2210, 1.0000,0.8350));
rects.push_back(Rect(0.9058,0.2210, 0.9134,0.8350));
rects.push_back(Rect(0.6324,0.1355, 0.8147,0.3082));
rects.push_back(Rect(0.6324,0.3082, 0.8147,0.9689));
rects.push_back(Rect(0.1270,0.3082, 0.6324,0.9689));
int nearBox_count = 0;
double TotalArea=0;
for (int x = 0; x < rects.size(); ++x) {
if (rects[b].isAdjacent(rects[x])) {
if (x==b) {
continue; //this is our box , so do not count it.
}
nearBox_count++;
printf("box[%d] is nearest to box[%d] \n", (b+1), (x+1));
}
}
printf("Total number of nearest box for [%d] is %d \n",(b+1),nearBox_count );
printf("\n");
}
int main() {
for (int i = 0; i < 16; ++i)
{
isNearest(i);
}
return 0;
}
它给出了正确的结果 -
box[1] is nearest to box[2]
box[1] is nearest to box[4]
box[1] is nearest to box[8]
box[1] is nearest to box[14]
Total number of nearest box for [1] is 4
box[2] is nearest to box[1]
box[2] is nearest to box[3]
box[2] is nearest to box[5]
box[2] is nearest to box[11]
Total number of nearest box for [2] is 4
box[3] is nearest to box[2]
box[3] is nearest to box[5]
box[3] is nearest to box[7]
box[3] is nearest to box[13]
box[3] is nearest to box[14]
box[3] is nearest to box[15]
Total number of nearest box for [3] is 6
box[4] is nearest to box[1]
box[4] is nearest to box[8]
box[4] is nearest to box[10]
box[4] is nearest to box[16]
Total number of nearest box for [4] is 4
box[5] is nearest to box[2]
box[5] is nearest to box[3]
box[5] is nearest to box[11]
box[5] is nearest to box[13]
Total number of nearest box for [5] is 4
box[6] is nearest to box[7]
box[6] is nearest to box[12]
box[6] is nearest to box[13]
Total number of nearest box for [6] is 3
box[7] is nearest to box[3]
box[7] is nearest to box[6]
box[7] is nearest to box[9]
box[7] is nearest to box[15]
Total number of nearest box for [7] is 4
box[8] is nearest to box[1]
box[8] is nearest to box[4]
box[8] is nearest to box[14]
box[8] is nearest to box[16]
Total number of nearest box for [8] is 4
box[9] is nearest to box[7]
box[9] is nearest to box[10]
box[9] is nearest to box[15]
box[9] is nearest to box[16]
Total number of nearest box for [9] is 4
box[10] is nearest to box[4]
box[10] is nearest to box[9]
Total number of nearest box for [10] is 2
box[11] is nearest to box[2]
box[11] is nearest to box[5]
box[11] is nearest to box[12]
Total number of nearest box for [11] is 3
box[12] is nearest to box[6]
box[12] is nearest to box[11]
box[12] is nearest to box[13]
Total number of nearest box for [12] is 3
box[13] is nearest to box[3]
box[13] is nearest to box[5]
box[13] is nearest to box[6]
box[13] is nearest to box[12]
Total number of nearest box for [13] is 4
box[14] is nearest to box[1]
box[14] is nearest to box[3]
box[14] is nearest to box[8]
box[14] is nearest to box[15]
Total number of nearest box for [14] is 4
box[15] is nearest to box[3]
box[15] is nearest to box[7]
box[15] is nearest to box[9]
box[15] is nearest to box[14]
box[15] is nearest to box[16]
Total number of nearest box for [15] is 5
box[16] is nearest to box[4]
box[16] is nearest to box[8]
box[16] is nearest to box[9]
box[16] is nearest to box[15]
Total number of nearest box for [16] is 4
虽然它可以识别最近的方框并计算邻居的数量，但我无法弄清楚如何对相似的方框进行分组（如上所述）并找到总和。
我被困在这里。任何人都可以帮助我吗？
更新了代码段
vector<CheckRect> rects;
unsigned isNearest(unsigned b, vector<unsigned>& neighbours) {
unsigned nearBox_count = 0;
for (unsigned x = 0; x < rects.size(); ++x) {
if (rects[b].isAdjacent(rects[x])) {
if (x==b) continue; //this is our box , so do not count it.
nearBox_count++;
printf("box[%d] is nearest to box[%d] \n", (b+1), (x+1));
neighbours.push_back(x);
}
}
printf("Total number of nearest box for [%d] is %d \n",
(b+1), nearBox_count );
printf("\n");
return nearBox_count;
}
int main(){
cin>>N;
for(int b=0; b<N; b++){
ifstream inputFile1("RectCoordinates.txt"); //input from the file previously generated
int rect_number;
double xa0,ya0,xa1,ya1;
int neighbours;
isNearest( b, &neighbours);// This is the line that causing my ERROR
}
vector<unsigned> nearBox_count(rects.size());
vector< vector<unsigned> > neighbours(rects.size());
for (unsigned i = 0; i < rects.size(); ++i) {
nearBox_count[i] = isNearest(i, neighbours[i]);
}
// Calculate the sums of neighbouring boxes
vector<unsigned> neighCount(rects.size(), 0);
for (unsigned i = 0; i < rects.size(); i++) {
for (unsigned j = 0; j < neighbours[i].size(); j++) {
neighCount[i] += nearBox_count[neighbours[i][j]];
}
}
// Calculate your result
map<unsigned,unsigned> finalCount;
for (unsigned i = 0; i < rects.size(); i++)
{
if (finalCount.count(nearBox_count[i]) == 0)
finalCount[nearBox_count[i]] = neighCount[i];
else
finalCount[nearBox_count[i]] += neighCount[i];
}
// Print the result
for (map<unsigned,unsigned>::iterator it = finalCount.begin();
it != finalCount.end(); ++it) {
printf("Sum neighbours for the neighbours of similar boxes with %d "
"neighbours is %d\n", it->first, it->second);
}
return 0;
}
给我错误 -
ss.cpp: In function ‘int main()’:
ss.cpp:102:29: error: invalid initialization of reference of type ‘std::vector<unsigned int>&’ from expression of type ‘unsigned int’
ss.cpp:22:10: error: in passing argument 2 of ‘unsigned int isNearest(unsigned int, std::vector<unsigned int>&)’
我该如何解决？
4 个答案:
答案 0 :(得分：3)
而不是尝试在某些数据结构中维持矩形之间的关系，最好让矩形对象本身变得聪明并且知道它的邻居数量以及它们是谁。
例如（用于说明想法的不完整的预言型）：
class Rect {
public:
//methods
Rect(double X1, double Y1, double X2, double Y2);
//const access
double getX1() const;
double getX2() const;
double getY1() const;
double getY2() const;
int numNeighbors() const { return neighbors.size();}
int sumOfNeighbors() const { int res(0); for(size_t i=0;i< neighbors.size();++i) res += neighbors[i]->numNeighbors(); return res;}
std::vector<Rect*> getNeighbors() {return neighbors};
void addNeighbor(Rect* newNeighbor) {neighbors.push_back(newNeighbor);}
//data
private:
double x1, x2, y1, y2; // coordinates
std::vector<Rect*> neighbors;
};
使用这样的rect类，你可以为每个矩形添加邻居，检索它自己的每个rect的所有邻居，以及它们的所有邻居 - 所有关系都保存在rect本身而不是一些外部对象中，主程序的代码应该非常最小的。
填充rects之后，您可以简单地迭代它们，选择具有所需邻居数量的那些，并对它们执行任何操作。
答案 1 :(得分：1)
我想如果你想彻底简化所有这些，你可以使用Kobelevskiy先生的建议：
#include <iostream>
#include <cstdlib>
#include <vector>
#include <stdio.h>
using namespace std;
class Rect {
public:
double x1, x2, y1, y2; // coordinates
//methods
Rect(double X1, double Y1, double X2, double Y2) {
if (X1 < X2) {
x1 = X1; x2 = X2;
} else {
x2 = X1; x1 = X2;
}
if (Y1 < Y2) {
y1 = Y1; y2 = Y2;
} else {
y2 = Y1; y1 = Y2;
}
}
~Rect()
{
};
int numNeighbors() const { return neighbors.size();}
int sumOfNeighbors() const { int res(0); for(size_t i=0;i< neighbors.size();++i) res += neighbors[i]->numNeighbors(); return res;}
std::vector<Rect*> getNeighbors() {return neighbors;};
void addNeighbor(Rect* newNeighbor) {neighbors.push_back(newNeighbor);}
//data
std::vector<Rect*> neighbors;
bool isAdjacent(Rect* rect) {
if (x1 == rect->x1 || x1 == rect->x2 ||
x2 == rect->x1 || x2 == rect->x2) {
// use only < when comparing y1 and rect->y2 avoids sharing only a corner
if (y1 >= rect->y1 && y1 < rect->y2) {
return true;
}
if (y2 > rect->y1 && y2 <= rect->y2) {
return true;
}
if (rect->y1 >= y1 && rect->y1 < y2) {
return true;
}
if (rect->y2 > y1 && rect->y2 <= y2) {
return true;
}
}
if (y1 == rect->y1 || y1 == rect->y2 ||
y2 == rect->y1 || y2 == rect->y2) {
if (x1 >= rect->x1 && x1 < rect->x2) {
return true;
}
if (x2 > rect->x1 && x2 <= rect->x2) {
return true;
}
if (rect->x1 >= x1 && rect->x1 < x2) {
return true;
}
if (rect->x2 > x1 && rect->x2 <= x2) {
return true;
}
}
return false;
}
};
vector<Rect*> rects;
void CalculateAdjacentsForRect(unsigned int rects_element){
for (unsigned int x = 0; x < rects.size(); x++) {
if (rects[rects_element]->isAdjacent(rects[x])) {
if (x==rects_element) {
continue; //this is our box , so do not count it.
}
rects[rects_element]->addNeighbor(rects[x]);
}
}
}
const int MAX_ADJACENT_RECTS = 10;
int main() {
//Rect( x1 , y1 , x2 , y2 )
rects.push_back(&Rect(0.0000,0.0000, 0.8147,0.1355));
rects.push_back(&Rect(0.8147,0.0000, 1.0000,0.1355));
rects.push_back(&Rect(0.8147,0.1355, 0.9058,0.8350));
rects.push_back(&Rect(0.0000,0.1355, 0.1270,0.9689));
rects.push_back(&Rect(0.9058,0.1355, 0.9134,0.2210));
rects.push_back(&Rect(0.9058,0.8350, 1.0000,1.0000));
rects.push_back(&Rect(0.8147,0.8350, 0.9058,1.0000));
rects.push_back(&Rect(0.1270,0.1355, 0.6324,0.3082));
rects.push_back(&Rect(0.1270,0.9689, 0.8147,1.0000));
rects.push_back(&Rect(0.0000,0.9689, 0.1270,1.0000));
rects.push_back(&Rect(0.9134,0.1355, 1.0000,0.2210));
rects.push_back(&Rect(0.9134,0.2210, 1.0000,0.8350));
rects.push_back(&Rect(0.9058,0.2210, 0.9134,0.8350));
rects.push_back(&Rect(0.6324,0.1355, 0.8147,0.3082));
rects.push_back(&Rect(0.6324,0.3082, 0.8147,0.9689));
rects.push_back(&Rect(0.1270,0.3082, 0.6324,0.9689));
for (unsigned int i = 0; i < rects.size(); i++)
{
CalculateAdjacentsForRect(i);
}
for (unsigned int i = 0; i < rects.size(); i++)
{
cout << "\nRect" << i << " has a neighbor sum of " << rects[i]->sumOfNeighbors();
}
cout << "\n";
for (int ix = 0; ix < MAX_ADJACENT_RECTS; ix++)
{
int num_rects_with_this_num_of_adjacents = 0;
int num_adjacents_total_for_similar_rects = 0;
for (unsigned int i = 0; i < rects.size(); i++) {
if ( rects[i]->numNeighbors() == ix ) {
num_rects_with_this_num_of_adjacents++;
num_adjacents_total_for_similar_rects += rects[i]->sumOfNeighbors();
}
}
cout << "\nThere are " << num_rects_with_this_num_of_adjacents << " rects with " << ix << " adjacent rects. They have a cum neighbor sum of " << num_adjacents_total_for_similar_rects;
}
return 0;
}
答案 2 :(得分：0)
好吧，我想你可以使用向量，但这种方式会占用大量内存空间。 说，制作矢量4neighbours - 乍一看，我会说每个盒子至少有4个邻居（你可能会为每个可能数量的邻居做这个 - 希望它可以计算，它不会是超级大）。然后，当检查每个矩形的邻居数量时，使用相应向量的回推。
printf("Total number of nearest box for [%d] is %d \n",(b+1),nearBox_count );
if(nearBox_count == 4)
4neighbours.pushback(rects[b]);
else if (nearBox_count == 5)
5neighbours.pushback(rects[b]);
else if -etc-
然后，遍历向量并为向量的每个成员检查邻居，并为每个邻居计算邻居并将其求和（您将嵌套两个循环 - 循环内的循环）
示例：未编码
int TotalNeighbours = 0;
while(go through all the boxes in the vector)
{
while(go through all the neighbours of each box)
{
TotalNeighbours++;
}
}
我相信这样的事情可能有用，但是上面提到的限制。 取决于最大邻居数量：
- 大量内存使用;
- 很多书面代码（很多if语句）;
编辑：一个框可以有0个邻居，其余的至少有1个邻居，而不是4个。
答案 3 :(得分：0)
除了尝试计算您的价值之外，我还对您的代码做了一些小改动。
由于您的所有列表索引都不是负数，并且将来可能会有非常多的矩形，我建议您将int的所有内容都设置为unsigned。这具有额外的优点，即在下面的代码中抑制有关比较有符号和无符号整数的某些编译器警告。
我建议您做的第二个更改是仅声明rects一次而不是每次遍历isNearest时。在下面的代码中，我通过使rects成为全局变量并创建一个单独的函数来初始化它来实现这一点。通过将rects设为全局变量，您现在可以用16替换所有rects.size()（减少添加完整数据集时忘记更改一个16的机会）。
#include <iostream>
#include <fstream>
#include <cstdlib>
#include <vector>
#include <map>
#include <stdio.h>
using namespace std;
class Rect {
public:
double x1, x2, y1, y2; // coordinates
Rect(double X1, double Y1, double X2, double Y2) {
if (X1 < X2) {
x1 = X1; x2 = X2;
} else {
x2 = X1; x1 = X2;
}
if (Y1 < Y2) {
y1 = Y1; y2 = Y2;
} else {
y2 = Y1; y1 = Y2;
}
}
bool isAdjacent(Rect rect) {
if (x1 == rect.x1 || x1 == rect.x2 ||
x2 == rect.x1 || x2 == rect.x2) {
// use only < when comparing y1 and rect.y2 avoids sharing only a corner
if (y1 >= rect.y1 && y1 < rect.y2) {
return true;
}
if (y2 > rect.y1 && y2 <= rect.y2) {
return true;
}
if (rect.y1 >= y1 && rect.y1 < y2) {
return true;
}
if (rect.y2 > y1 && rect.y2 <= y2) {
return true;
}
}
if (y1 == rect.y1 || y1 == rect.y2 ||
y2 == rect.y1 || y2 == rect.y2) {
if (x1 >= rect.x1 && x1 < rect.x2) {
return true;
}
if (x2 > rect.x1 && x2 <= rect.x2) {
return true;
}
if (rect.x1 >= x1 && rect.x1 < x2) {
return true;
}
if (rect.x2 > x1 && rect.x2 <= x2) {
return true;
}
}
return false;
}
};
vector<Rect> rects;
unsigned isNearest(unsigned b, vector<unsigned>& neighbours) {
unsigned nearBox_count = 0;
for (unsigned x = 0; x < rects.size(); ++x) {
if (rects[b].isAdjacent(rects[x])) {
if (x==b) continue; //this is our box , so do not count it.
nearBox_count++;
printf("box[%d] is nearest to box[%d] \n", (b+1), (x+1));
neighbours.push_back(x);
}
}
printf("Total number of nearest box for [%d] is %d \n",
(b+1), nearBox_count );
printf("\n");
return nearBox_count;
}
void initRects(void) {
//Rect( x1 , y1 , x2 , y2 )
rects.push_back(Rect(0.0000,0.0000, 0.8147,0.1355));
rects.push_back(Rect(0.8147,0.0000, 1.0000,0.1355));
rects.push_back(Rect(0.8147,0.1355, 0.9058,0.8350));
rects.push_back(Rect(0.0000,0.1355, 0.1270,0.9689));
rects.push_back(Rect(0.9058,0.1355, 0.9134,0.2210));
rects.push_back(Rect(0.9058,0.8350, 1.0000,1.0000));
rects.push_back(Rect(0.8147,0.8350, 0.9058,1.0000));
rects.push_back(Rect(0.1270,0.1355, 0.6324,0.3082));
rects.push_back(Rect(0.1270,0.9689, 0.8147,1.0000));
rects.push_back(Rect(0.0000,0.9689, 0.1270,1.0000));
rects.push_back(Rect(0.9134,0.1355, 1.0000,0.2210));
rects.push_back(Rect(0.9134,0.2210, 1.0000,0.8350));
rects.push_back(Rect(0.9058,0.2210, 0.9134,0.8350));
rects.push_back(Rect(0.6324,0.1355, 0.8147,0.3082));
rects.push_back(Rect(0.6324,0.3082, 0.8147,0.9689));
rects.push_back(Rect(0.1270,0.3082, 0.6324,0.9689));
}
void readRects(const string& filename) {
ifstream fpInput(filename.c_str());
double dTemp[4];
while (true) {
for (unsigned i = 0; i < 4; i++) fpInput >> dTemp[i];
if (!fpInput.good()) break;
rects.push_back(Rect(dTemp[0], dTemp[1], dTemp[2], dTemp[3]));
}
fpInput.close();
}
int main() {
// Initialize the vector rects
//initRects();
readRects("RectCoordinates.txt");
vector<unsigned> nearBox_count(rects.size());
vector< vector<unsigned> > neighbours(rects.size());
for (unsigned i = 0; i < rects.size(); ++i) {
nearBox_count[i] = isNearest(i, neighbours[i]);
}
// Calculate the sums of neighbouring boxes
vector<unsigned> neighCount(rects.size(), 0);
for (unsigned i = 0; i < rects.size(); i++) {
for (unsigned j = 0; j < neighbours[i].size(); j++) {
neighCount[i] += nearBox_count[neighbours[i][j]];
}
}
// Calculate your result
map<unsigned,unsigned> finalCount;
for (unsigned i = 0; i < rects.size(); i++)
{
if (finalCount.count(nearBox_count[i]) == 0) {
finalCount[nearBox_count[i]] = neighCount[i];
} else {
finalCount[nearBox_count[i]] += neighCount[i];
}
}
// Print the result
for (map<unsigned,unsigned>::iterator it = finalCount.begin();
it != finalCount.end(); ++it) {
printf("Sum neighbours for the neighbours of similar boxes with %d "
"neighbours is %d\n", it->first, it->second);
}
return 0;
}
更新：现在可以通过在源文件中指定Rect或从外部文件加载来使用上述代码。在上面的修改示例中，输入文件为RectCoordinates.txt：
0.0000 0.0000 0.8147 0.1355
0.8147 0.0000 1.0000 0.1355
0.8147 0.1355 0.9058 0.8350
0.0000 0.1355 0.1270 0.9689
0.9058 0.1355 0.9134 0.2210
0.9058 0.8350 1.0000 1.0000
0.8147 0.8350 0.9058 1.0000
0.1270 0.1355 0.6324 0.3082
0.1270 0.9689 0.8147 1.0000
0.0000 0.9689 0.1270 1.0000
0.9134 0.1355 1.0000 0.2210
0.9134 0.2210 1.0000 0.8350
0.9058 0.2210 0.9134 0.8350
0.6324 0.1355 0.8147 0.3082
0.6324 0.3082 0.8147 0.9689
0.1270 0.3082 0.6324 0.9689
以上输出结果：
Sum neighbours for the neighbours of similar boxes with 2 neighbours is 8
Sum neighbours for the neighbours of similar boxes with 3 neighbours is 32
Sum neighbours for the neighbours of similar boxes with 4 neighbours is 165
Sum neighbours for the neighbours of similar boxes with 5 neighbours is 22
Sum neighbours for the neighbours of similar boxes with 6 neighbours is 25
相关问题
最新问题
- 我写了这段代码，但我无法理解我的错误
- 我无法从一个代码实例的列表中删除 None 值，但我可以在另一个实例中。为什么它适用于一个细分市场而不适用于另一个细分市场？
- 是否有可能使 loadstring 不可能等于打印？卢阿
- java中的random.expovariate()
- Appscript 通过会议在 Google 日历中发送电子邮件和创建活动
- 为什么我的 Onclick 箭头功能在 React 中不起作用？
- 在此代码中是否有使用“this”的替代方法？
- 在 SQL Server 和 PostgreSQL 上查询，我如何从第一个表获得第二个表的可视化
- 每千个数字得到
- 更新了城市边界 KML 文件的来源？