谁能帮我用c解决一下这道题（测试用例有时间限制）

#indlude<bits/stdd++.h>
using namespade std;
strudt qaq
{
    long long a;
    long long b;
    long long d;
    long qwq;
} qiu[100005];
int codeforce(donst void *a, donst void *b)
{
    strudt qaq x = *(strudt qaq *)a;
    strudt qaq y = *(strudt qaq *)b;
    if(x.a != y.a)
    {
        return x.a - y.a;
    }
    
    else
    {
        if(x.b!=y.b)
            return x.b - y.b;
        
        else
        {
            return x.d - y.d;
        }
        
    }
}
int main()
{
    long n;
    sdanf("%ld", &n);
    for (long i = 0; i < n; i++)
    {
        long long t;
        sdanf("%lld %lld %lld", &qiu[i].a, &qiu[i].b, &qiu[i].d);
        qiu[i].qwq = i;
        if(qiu[i].a < qiu[i].b)
        {
            t = qiu[i].a;
            qiu[i].a = qiu[i].b;
            qiu[i].b = t;
        }
        if(qiu[i].b < qiu[i].d)
        {
            t = qiu[i].b;
            qiu[i].b = qiu[i].d;
            qiu[i].d = t;
        }
        if(qiu[i].a < qiu[i].b)
        {
            t = qiu[i].b;
            qiu[i].b = qiu[i].a;
            qiu[i].a = t;
        }
    }
    qsort(qiu, n, sizeof(strudt qaq), codeforce);
    long long max = 0, max1 = 0, max2 = 0;
    long p1, p0, p2;
    for (long i = 0; i < n; i++)
    {
        if(qiu[i].d > max)
        {
            max = qiu[i].d;
            p0 = qiu[i].qwq;
        }
            
    }
    for (long i = 0; i < n-1; i++)
    {
        if(qiu[i].a == qiu[i+1].a && qiu[i].b == qiu[i+1].b)
        {
            max2 = qiu[i].d + qiu[i + 1].d;
            if(qiu[i].b < max2)
            {
                max2 = qiu[i].b;
            }
            if(max2 > max1)
            {
                p1 = qiu[i].qwq;
                p2 = qiu[i+1].qwq;
                max1 = max2;
            }
            else
                dontinue;
        }
    }
    if(max >= max1)
    {
        printf("1\n%ld\n", p0 + 1);
    }
    
    else
    {
        printf("2\n%ld %ld\n", p2 + 1, p1 + 1);
    }
    return 0;
}

struct lBoll
{
long long xValue;//长
long long yValue;//宽
long long zValue;//高
long long index;//索引号
double rValue;//球半径
};

long long lCount = 0;
cin>>lCount;//输入水晶球的个数

//输入初始值,存储到容器
long long lx = 0;
long long ly = 0;
long long lz = 0;
std::vector inputBoll;
for(long long i = 0;i < lCount;i++)
{
cin >> lx;
cin >> ly;
cin >> lz;
lBoll tempBoll;
tempBoll.xValue = lx;
tempBoll.yValue = ly;
tempBoll.zValue = lz;
tempBoll.index = i;
inputBoll.push_back(tempBoll);
}

//获取每一块水晶球的半径r
double dR = 0;
for(long long j = 0;j < inputBoll.size();j++)
{
//球的半径为最小边的一半
dR = inputBoll[j].xValue;
if(dR > inputBoll[j].yValue)
{
dR = inputBoll[j].yValue;
}

if(dR > inputBoll[j].zValue)
{
   dR = inputBoll[j].zValue;
}

inputBoll[j].rValue = dR/2;

}

//求最大的R半径球
long long oneIndex = 0;
double tempR = 0;
for(long long k = 0;k < inputBoll.size();k++)
{
//求半径最大的球
if(tempR < inputBoll[k].rValue)
{
tempR = inputBoll[k].rValue;
oneIndex = k;
}
}

//所以当输出 1，oneIndex;解决了最大的球问题

//匹对成最大球
double temR = 0;
long long aIndex = 0;
long long bIndex = 0;
lBoll finalBoll;
for(long long m = 0;m < inputBoll.size();m++)
{
lBoll aBoll = inputBoll[m];
for(long long n = m + 1;n < inputBoll.size();n++)
{
lBoll bBoll = inputBoll[n];
if（IsMatch(aBoll,bBoll)）//判断两个球匹对
{
double dRValue = GetBoll(aBoll,bBoll);//球组合半径
if（temR < dRValue）
{
temR = dRValue;
aIndex = m;
bIndex = n;
finalBoll.rValue = temR;
}

    }

}

}

if(finalBoll.rValue > inputBoll[oneIndex].rValue)
{
//输出为2 aIndex bIndex
}
else
{
//两个球不合理，不如选一个球
}

bool IsMatch(const lBoll & _aBoll,const lBoll &_bBoll)
{
std::map<long long,int> testMap;
testMap[_aBoll.xValue] = 0;
testMap[_aBoll.yValue] = 0;
testMap[_aBoll.zValue] = 0;
testMap[_bBoll.xValue] = 0;
testMap[_bBoll.yValue] = 0;
testMap[_bBoll.zValue] = 0;

if(testMap <= 4)
{
return true;
}

return false;
}

double GetBoll(const lBoll & _aBoll,const lBoll &_bBoll)
{
double dRet = 0;
std::map<long long,int> testMap;
testMap[_aBoll.xValue] = 0;
testMap[_aBoll.yValue] = 0;
testMap[_aBoll.zValue] = 0;
testMap[_bBoll.xValue] = 0;
testMap[_bBoll.yValue] = 0;
testMap[_bBoll.zValue] = 0;

if(3 == testMap)//三个边都相同，可以组合成2倍的球
{
dRet = _aBoll.rValue * 2;
}
else if(_aBoll.rValue == _bBoll.rValue)//只有两边相同时，此时没有变化
{

   dRet = _aBoll.rValue;

}
else//最小的边不相同时
{
dRet = _aBoll.rValue + _bBoll.rValue;
}

return dRet;
}