【深基3.习8】三角形分类

题目描述

给出三条线段 $a,b,c$ 的长度，均是不大于 $10000$ 的正整数。打算把这三条线段拼成一个三角形，它可以是什么三角形呢？

• 如果三条线段不能组成一个三角形，输出Not triangle；
• 如果是直角三角形，输出Right triangle；
• 如果是锐角三角形，输出Acute triangle；
• 如果是钝角三角形，输出Obtuse triangle；
• 如果是等腰三角形，输出Isosceles triangle；
• 如果是等边三角形，输出Equilateral triangle。

如果这个三角形符合以上多个条件，请按以上顺序分别输出，并用换行符隔开。

输入格式

输入 3 个整数 $a$、$b$ 和 $c$。

输出格式

输出若干行判定字符串。

样例 #1

样例输入 #1

3 3 3

样例输出 #1

Acute triangle
Isosceles triangle
Equilateral triangle

样例 #2

样例输入 #2

3 4 5

样例输出 #2

Right triangle

样例 #3

样例输入 #3

6 10 6

样例输出 #3

Obtuse triangle
Isosceles triangle

样例 #4

样例输入 #4

1 14 5

样例输出 #4

Not triangle

提示

当两短边的平方和大于一长边的平方，说明是锐角三角形。

当两短边的平方和等于一长边的平方，说明是直角三角形。

当两短边的平方和小于一长边的平方，说明是钝角三角形。

#include <iostream>
#include <cmath>
#include <algorithm>
using namespace std;
int main()
{
	long long a,b,c,t[4];
	cin>>a>>b>>c;
	t[1]=a;t[2]=b;t[3]=c;
	if(a+b<=c||b+c<=a||c+a<=b)
	{
		cout<<"Not triangle"<<endl;
	}
	sort(&t[1],&t[2],&t[3]);
	if(t[1]+t[2]==pow(t[3],2)) cout<<"Right triangle"<<endl;
	if(t[1]+t[2]>pow(t[3],2)) cout<<"Acute triangle"<<endl;
	if(t[1]+t[2]<pow(t[3],2)) cout<<"Obtuse triangle"<<endl;
	if(t[1]==t[2]||t[2]==t[3]||t[1]==t[3]) cout<<"Isosceles triangle"<<endl;
	if(t[1]==t[2]&&t[2]==t[3]) cout<<"Equilateral triangle"<<endl;
	return 0; 
}

结果在编译器上运行了，弹出下面一堆乱码，提交也显示Erro

// Default predicates for internal use -*- C++ -*-

// Copyright (C) 2013-2014 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library.  This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 3, or (at your option)
// any later version.

// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.

// Under Section 7 of GPL version 3, you are granted additional
// permissions described in the GCC Runtime Library Exception, version
// 3.1, as published by the Free Software Foundation.

// You should have received a copy of the GNU General Public License and
// a copy of the GCC Runtime Library Exception along with this program;
// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
// <http://www.gnu.org/licenses/>.

/** @file predefined_ops.h
*  This is an internal header file, included by other library headers.
*  You should not attempt to use it directly.
*/

#ifndef _GLIBCXX_PREDEFINED_OPS_H
#define _GLIBCXX_PREDEFINED_OPS_H	1

namespace __gnu_cxx
{
namespace __ops
{
 struct _Iter_less_iter
 {
   template<typename _Iterator1, typename _Iterator2>
     bool
     operator()(_Iterator1 __it1, _Iterator2 __it2) const
     { return *__it1 < *__it2; }
 };

 inline _Iter_less_iter
 __iter_less_iter()
 { return _Iter_less_iter(); }

 struct _Iter_less_val
 {
   template<typename _Iterator, typename _Value>
     bool
     operator()(_Iterator __it, _Value& __val) const
     { return *__it < __val; }
   };

 inline _Iter_less_val
 __iter_less_val()
 { return _Iter_less_val(); }

 inline _Iter_less_val
 __iter_comp_val(_Iter_less_iter)
 { return _Iter_less_val(); }

 struct _Val_less_iter
 {
   template<typename _Value, typename _Iterator>
     bool
     operator()(_Value& __val, _Iterator __it) const
     { return __val < *__it; }
   };

 inline _Val_less_iter
 __val_less_iter()
 { return _Val_less_iter(); }

 inline _Val_less_iter
 __val_comp_iter(_Iter_less_iter)
 { return _Val_less_iter(); }

 struct _Iter_equal_to_iter
 {
   template<typename _Iterator1, typename _Iterator2>
     bool
     operator()(_Iterator1 __it1, _Iterator2 __it2) const
     { return *__it1 == *__it2; }
   };

 inline _Iter_equal_to_iter
 __iter_equal_to_iter()
 { return _Iter_equal_to_iter(); }

 struct _Iter_equal_to_val
 {
   template<typename _Iterator, typename _Value>
     bool
     operator()(_Iterator __it, _Value& __val) const
     { return *__it == __val; }
   };

 inline _Iter_equal_to_val
 __iter_equal_to_val()
 { return _Iter_equal_to_val(); }

 inline _Iter_equal_to_val
 __iter_comp_val(_Iter_equal_to_iter)
 { return _Iter_equal_to_val(); }

 template<typename _Compare>
   struct _Iter_comp_iter
   {
     _Compare _M_comp;

     _Iter_comp_iter(_Compare __comp)
   : _M_comp(__comp)
     { }

     template<typename _Iterator1, typename _Iterator2>
       bool
       operator()(_Iterator1 __it1, _Iterator2 __it2)
       { return bool(_M_comp(*__it1, *__it2)); }; 
   };

 template<typename _Compare>
   inline _Iter_comp_iter<_Compare>
   __iter_comp_iter(_Compare __comp)
   { return _Iter_comp_iter<_Compare>(__comp); }

 template<typename _Compare>
   struct _Iter_comp_val
   {
     _Compare _M_comp;

     _Iter_comp_val(_Compare __comp)
   : _M_comp(__comp)
     { }

     template<typename _Iterator, typename _Value>
   bool
   operator()(_Iterator __it, _Value& __val)
   { return bool(_M_comp(*__it, __val)); }
   };

 template<typename _Compare>
  inline _Iter_comp_val<_Compare>
   __iter_comp_val(_Compare __comp)
   { return _Iter_comp_val<_Compare>(__comp); }

 template<typename _Compare>
   inline _Iter_comp_val<_Compare>
   __iter_comp_val(_Iter_comp_iter<_Compare> __comp)
   { return _Iter_comp_val<_Compare>(__comp._M_comp); }

 template<typename _Compare>
   struct _Val_comp_iter
   {
     _Compare _M_comp;

     _Val_comp_iter(_Compare __comp)
   : _M_comp(__comp)
     { }

     template<typename _Value, typename _Iterator>
   bool
   operator()(_Value& __val, _Iterator __it)
   { return bool(_M_comp(__val, *__it)); }
   };

 template<typename _Compare>
   inline _Val_comp_iter<_Compare>
   __val_comp_iter(_Compare __comp)
   { return _Val_comp_iter<_Compare>(__comp); }

 template<typename _Compare>
   inline _Val_comp_iter<_Compare>
   __val_comp_iter(_Iter_comp_iter<_Compare> __comp)
   { return _Val_comp_iter<_Compare>(__comp._M_comp); }

 template<typename _Value>
   struct _Iter_equals_val
   {
     _Value& _M_value;

     _Iter_equals_val(_Value& __value)
   : _M_value(__value)
     { }

     template<typename _Iterator>
   bool
   operator()(_Iterator __it)
   { return *__it == _M_value; }
   };

 template<typename _Value>
   inline _Iter_equals_val<_Value>
   __iter_equals_val(_Value& __val)
   { return _Iter_equals_val<_Value>(__val); }

 template<typename _Iterator1>
   struct _Iter_equals_iter
   {
     typename std::iterator_traits<_Iterator1>::reference _M_ref;

     _Iter_equals_iter(_Iterator1 __it1)
   : _M_ref(*__it1)
     { }

     template<typename _Iterator2>
   bool
   operator()(_Iterator2 __it2)
   { return *__it2 == _M_ref; }
   };

 template<typename _Iterator>
   inline _Iter_equals_iter<_Iterator>
   __iter_comp_iter(_Iter_equal_to_iter, _Iterator __it)
   { return _Iter_equals_iter<_Iterator>(__it); }

 template<typename _Predicate>
   struct _Iter_pred
   {
     _Predicate _M_pred;

     _Iter_pred(_Predicate __pred)
   : _M_pred(__pred)
     { }

     template<typename _Iterator>
   bool
   operator()(_Iterator __it)
   { return bool(_M_pred(*__it)); }
   };

 template<typename _Predicate>
   inline _Iter_pred<_Predicate>
   __pred_iter(_Predicate __pred)
   { return _Iter_pred<_Predicate>(__pred); }

 template<typename _Compare, typename _Value>
   struct _Iter_comp_to_val
   {
     _Compare _M_comp;
     _Value& _M_value;

     _Iter_comp_to_val(_Compare __comp, _Value& __value)
   : _M_comp(__comp), _M_value(__value)
     { }

     template<typename _Iterator>
   bool
   operator()(_Iterator __it)
   { return bool(_M_comp(*__it, _M_value)); }
   };

 template<typename _Compare, typename _Value>
   _Iter_comp_to_val<_Compare, _Value>
   __iter_comp_val(_Compare __comp, _Value &__val)
   { return _Iter_comp_to_val<_Compare, _Value>(__comp, __val); }

 template<typename _Compare, typename _Iterator1>
   struct _Iter_comp_to_iter
   {
     _Compare _M_comp;
     typename std::iterator_traits<_Iterator1>::reference _M_ref;

     _Iter_comp_to_iter(_Compare __comp, _Iterator1 __it1)
   : _M_comp(__comp), _M_ref(*__it1)
     { }

     template<typename _Iterator2>
   bool
   operator()(_Iterator2 __it2)
   { return bool(_M_comp(*__it2, _M_ref)); }
   };

 template<typename _Compare, typename _Iterator>
   inline _Iter_comp_to_iter<_Compare, _Iterator>
   __iter_comp_iter(_Iter_comp_iter<_Compare> __comp, _Iterator __it)
   { return _Iter_comp_to_iter<_Compare, _Iterator>(__comp._M_comp, __it); }

 template<typename _Predicate>
   struct _Iter_negate
   {
     _Predicate _M_pred;

     _Iter_negate(_Predicate __pred)
   : _M_pred(__pred)
     { }

     template<typename _Iterator>
   bool
   operator()(_Iterator __it)
   { return !bool(_M_pred(*__it)); }
   };

 template<typename _Predicate>
   inline _Iter_negate<_Predicate>
   __negate(_Iter_pred<_Predicate> __pred)
   { return _Iter_negate<_Predicate>(__pred._M_pred); }

} // namespace __ops
} // namespace __gnu_cxx

#endif

这是为什么，中毒了吗，帮帮我啊